#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
};
-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 */
OutputTermStr(term_ve, 1);
}
-void GetTermcapInfo(void)
+static void GetTermcapInfo(void)
{
char *term, *buf, *data;
int bufSize = 8192;
term_vi = term_ve = NULL;
}
-void OutputTermStr(char *str, int flush)
+static void OutputTermStr(char *str, int flush)
{
if (str) {
fputs(str, stdout);
}
}
-void DrawTitle(void)
+static void DrawTitle(void)
{
int rows, cols;
char *s;
s = malloc(cols + 1);
sprintf(s, " " MSG_TITLE " %s", version_string);
const int titlelen = strlen(s);
- memset(&s[titlelen], ' ', cols - strlen(MSG_TITLE)); // pad
+ 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);
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;
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;
messageWidth = MIN(x - messageXPos - 2, MSG_WIDTH);
messageHeight = MIN(y - messageYPos - 1, MSG_HEIGHT);
- if (messageHeight <= 0) {
- messageWidth = 27;
+ 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))
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);
+ 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;
waddch(msgwin, '\n');
}
-void Message(char *fmt, ...)
+void msg_add(char *fmt, ...)
{ //print game/bot message
va_list args;
char s[MSG_WIDTH];
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), ' ');
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(" ");
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
+ case 2: // ascii horizontally grouped
+ switch (type & 0xC0) {
+ case 0x40: // right neighbour
addstr("[["); break;
- case 128: //left
+ case 0x80: // left
addstr("]]"); break;
- default: //both/none
+ 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:
+ } // 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; //ascii non-grouped
- } //draw block
+ 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('|');
#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);
} //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)
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
}
git.shiar.nl / netris.git / blobdiff