NetBSD/games/testpat/testpat.c

/* $NetBSD: testpat.c,v 1.6 2021/11/13 20:59:13 nat Exp $ */

/*-
 * Copyright (c) 2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/cdefs.h>
__RCSID("$NetBSD: testpat.c,v 1.6 2021/11/13 20:59:13 nat Exp $");

#include <sys/types.h>
#include <sys/time.h>

#include <curses.h>
#include <err.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

static int colour_list[6] = {
	COLOR_YELLOW,
	COLOR_CYAN,
	COLOR_GREEN,
	COLOR_MAGENTA,
	COLOR_RED,
	COLOR_BLUE,
};
static int numcolours = (int)__arraycount(colour_list);

int main(int argc, char *argv[]) {
	int i, col, colour, line, x_limit, y_limit, colourOK, spacing;
	int xpos, ypos, spacing_residual, spacing_start, spacing_end;
	int grid_x, grid_y, **circle_pos;
	size_t ncpos;
	float grid_unit;
	const char *title = "NetBSD";
	float coord_x, circle_int;
	float a_axis, b_axis;

	if (!initscr()) {
		errx(EXIT_FAILURE, "Unknown terminal type");
	}

	curs_set(0);

	if (argc > 2) {
		endwin();
		fprintf(stderr, "Usage: %s <title>", getprogname());
		return EXIT_FAILURE;
	}

	if (argc == 2) {
		title = argv[1];
		if (strlen(title) >= (size_t)COLS) {
			endwin();
			errx(EXIT_FAILURE,
			    "Title string is longer than display cols");
		}
	}

	colourOK = has_colors();

	if (COLS < 13 || LINES < 13) {
		endwin();
		errx(EXIT_FAILURE, "Terminal size must be at least 72x25.");
	}

	if (colourOK) {
		start_color();

	    	init_pair(0, COLOR_WHITE, COLOR_BLACK);
	    	init_pair(1, COLOR_WHITE, COLOR_RED);
	    	init_pair(2, COLOR_WHITE, COLOR_GREEN);
	    	init_pair(3, COLOR_WHITE, COLOR_YELLOW);
	    	init_pair(4, COLOR_WHITE, COLOR_BLUE);
	    	init_pair(5, COLOR_WHITE, COLOR_MAGENTA);
	    	init_pair(6, COLOR_WHITE, COLOR_CYAN);
	    	init_pair(7, COLOR_BLACK, COLOR_WHITE);

		attrset(COLOR_PAIR(0));
	}

	x_limit = (COLS - 1) / 2;
	x_limit = x_limit * 2;
	y_limit = (LINES - 2) / 2;
	y_limit = y_limit * 2;
	spacing = 2 * y_limit / numcolours;
	spacing_residual = ((2 * y_limit) % numcolours) / 2;
	a_axis = y_limit / 2;
	b_axis = y_limit;
	grid_unit = b_axis / 13;
	grid_y = grid_unit;
	grid_x = grid_unit * 2;


	ncpos = y_limit * sizeof(*circle_pos)
	    + y_limit * 2 * sizeof(**circle_pos);
	circle_pos = malloc(ncpos);
	if (circle_pos == NULL) {
		endwin();
		errx(EXIT_FAILURE, "Can't allocate circle positions");
	}
	for (i = 0; i < y_limit; i++) {
	    circle_pos[i] = (void *)&circle_pos[y_limit + i * 2];
	    circle_pos[i][0] = circle_pos[i][1] = -1;
	}

	for (i = 0; i < y_limit; i++) {
		/* Draw an ellipse (looks more circular.) */
		circle_int = (i - a_axis) / a_axis;
		circle_int = 1 - powf(circle_int, 2);
		circle_int = circle_int * powf(b_axis, 2);
#if 0
		/* Draw a circle, commented out as elipse looks better.*/
		circle_int = powf(a_axis, 2) - powf(i - a_axis, 2);
#endif
		coord_x = sqrtf(circle_int);
		circle_pos[i][0] = (-coord_x + ((float)x_limit / 2));
		circle_pos[i][1] = (coord_x + ((float)x_limit / 2));
	}

	clear();

	attron(A_ALTCHARSET);
	move(0, 0);

	/* Draw a grid. */
	for (line = 1; line < y_limit; line += grid_y) {
		for (col = 1; col < x_limit; col = col + grid_x) {
			xpos = col;
			while ((xpos < col + grid_x - 1) && (xpos <
			    x_limit)) {
				mvaddch(line + grid_y - 1, xpos, 113 |
				    A_ALTCHARSET);
				xpos++;
			}
			if (xpos < x_limit)
				mvaddch(line + grid_y - 1, xpos, 110 |
				    A_ALTCHARSET);
		}
		ypos = line;
		while (ypos < line + grid_y - 1) {
			for (col = grid_x - 1; col < x_limit; col += grid_x) {
				mvaddch(ypos, col + 1, 120 | A_ALTCHARSET);
			}
			ypos++;
		}
	}

	for (line = 1; line < y_limit; line += grid_y) {
		mvaddch(line + grid_y - 1, 0, 116 | A_ALTCHARSET);
		mvaddch(line + grid_y - 1, x_limit, 117 | A_ALTCHARSET);

		ypos = line;
		while (ypos < line + grid_y - 1) {
			mvaddch(ypos, 0, 120 | A_ALTCHARSET);
			mvaddch(ypos, x_limit, 120 | A_ALTCHARSET);
			ypos++;
		}
	}

	for (col = 1; col < x_limit; col += grid_x) {
		mvaddch(0, col + grid_x - 1, 119 | A_ALTCHARSET);
		mvaddch(y_limit, col + grid_x - 1, 118 | A_ALTCHARSET);

		xpos = col;
		while ((xpos < col + grid_x - 1) && (xpos < x_limit)) {
			mvaddch(0, xpos, 113 | A_ALTCHARSET);
			mvaddch(y_limit, xpos, 113 | A_ALTCHARSET);
			xpos++;
		}
	}

	mvaddch(0, 0, 108 | A_ALTCHARSET);
	mvaddch(0, x_limit, 107 | A_ALTCHARSET);
	mvaddch(y_limit, 0, 109 | A_ALTCHARSET);
	mvaddch(y_limit, x_limit, 106 | A_ALTCHARSET);

	/* Draw a white circle. */
	for (i = 1; i < y_limit; i++) {
		for (col = circle_pos[i][0]; col <= circle_pos[i][1]; col++) {
			mvaddch(i, col, 32 | A_REVERSE);
		}
	}

	/* Add title segment. */
	for (i = roundf(1 * grid_unit); i < roundf(2 * grid_unit); i++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
			attrset(A_NORMAL);

		for (col = roundf((4 * grid_unit * 2) +
		    circle_pos[y_limit / 2][0]); col <= roundf((9 * grid_unit
		    * 2) + circle_pos[y_limit / 2][0]); col++)
			mvaddch(i, col, ' ');
	}

	i = roundf(1.4 * grid_unit);

	if (!colourOK)
		attrset(A_NORMAL);

	col = y_limit - (strlen(title) / 2) + circle_pos[y_limit / 2][0];
		mvprintw(i, col, "%s", title);

	/* Add black segments at top. */
	for (line = roundf(2 * grid_unit); line < 4 * grid_unit; line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
			attrset(A_NORMAL);

		for (col = 0; col <= roundf((3.5 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos <= circle_pos[line][1])
					mvaddch(line, xpos, ' ');
		}

		for (col = roundf((9.5 * grid_unit * 2)); col <
		    roundf((13 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos <= circle_pos[line][1])
					mvaddch(line, xpos, ' ');
		}
	}

	/* Add black and white squares close to top. */
	int gap = (circle_pos[(int)(5 * grid_unit)][1] -
	    circle_pos[(int)(5 * grid_unit)][0]) / 13;

	for (i = roundf(3 * grid_unit); i < roundf(4 * grid_unit); i++) {
		for (xpos = 0; xpos <= x_limit; xpos += 2 * gap) {
			if (colourOK)
    				attrset(COLOR_PAIR(COLOR_BLACK));
			else
				attrset(A_NORMAL);

			for (col = xpos; col < xpos + gap; col++) {
				if (col >= circle_pos[i][0] &&
				    col <= circle_pos[i][1])
					mvaddch(i, col, ' ');
			}

			if (colourOK)
    				attrset(COLOR_PAIR(COLOR_WHITE));
			else
				attrset(A_REVERSE);

			for (col = xpos + gap ; col < xpos + (2 * gap);
			    col++) {
				if (col >= circle_pos[i][0] &&
				    col <= circle_pos[i][1])
					mvaddch(i, col, ' ');
			}
		}
	}

	/* Add colour bars. */
	for (i = 0; i < numcolours; i++) {
		colour = colour_list[i];
		if (colourOK)
	    		attrset(COLOR_PAIR(colour));
		else if (i & 1)
			attrset(A_NORMAL);
		else
			attrset(A_REVERSE);

		if (i == 0)
			spacing_start = 0;
		else
			spacing_start = (spacing * i) + spacing_residual;

		if (i == numcolours - 1)
			spacing_end = circle_pos[y_limit / 2][1];
		else
			spacing_end = (spacing * (i + 1)) + spacing_residual;

	    	for (line = roundf(4 * grid_unit); line < (y_limit / 2);
		    line++) {
			for (col = spacing_start; col < spacing_end; col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos <= circle_pos[line][1])
	    				mvprintw(line, xpos, " ");
			}
	    	}
	}

	/* Add black segment under centre line. */
	for (line = y_limit / 2; line < (9.5 * grid_unit); line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
			attrset(A_NORMAL);

		for (col = circle_pos[line][0]; col <= circle_pos[line][1];
		    col++)
			mvaddch(line, col, ' ');

		for (col = roundf((1.5 * grid_unit * 2)); col <
		    roundf((4.3 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, 120 | A_ALTCHARSET);
		}

		for (col = roundf((4.3 * grid_unit * 2)); col <
		    roundf((7.6 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, '|');
		}

		for (col = roundf((7.6 * grid_unit * 2)); col <
		    roundf((11.5 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, 97 | A_ALTCHARSET);
		}
	}

	/* Add black segment close to bottom. */
	for (line = roundf(9.5 * grid_unit); line <= (10.5 * grid_unit);
	    line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
			attrset(A_NORMAL);

		for (col = roundf((0 * grid_unit * 2)); col <
		    roundf((4 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, ' ');
		}

		for (col = roundf((4 * grid_unit * 2)); col <
		    roundf((6.5 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, 97 | A_ALTCHARSET);
		}

		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_WHITE));
		else
			attrset(A_REVERSE);

		for (col = roundf((6.5 * grid_unit * 2)); col <
		    roundf((9 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, 97 | A_ALTCHARSET);
		}

		for (col = roundf((9 * grid_unit * 2)); col <
		    roundf((13 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, ' ');
		}
	}

	/* Add name segment close to bottom. */
	for (line = roundf(10.5 * grid_unit); line < (12 * grid_unit);
	    line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
			attrset(A_NORMAL);

		for (col = roundf(3.5 * grid_unit * 2); col <= roundf(9.5 *
		    grid_unit * 2); col++) {
			xpos = col + circle_pos[y_limit / 2][0];
			if (xpos >= circle_pos[line][0] &&
			    xpos < circle_pos[line][1])
				mvaddch(line, xpos, ' ');
		}

		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_WHITE));
		else
			attrset(A_REVERSE);

		for (col = roundf(0 * grid_unit * 2); col <= roundf(3.5 *
		    grid_unit * 2); col++) {
			xpos = col + circle_pos[y_limit / 2][0];
			if (xpos >= circle_pos[line][0] &&
			    xpos < circle_pos[line][1])
				mvaddch(line, xpos, ' ');
		}

		for (col = roundf(9.5 * grid_unit * 2); col <= roundf(13 *
		    grid_unit * 2); col++) {
			xpos = col + circle_pos[y_limit / 2][0];
			if (xpos >= circle_pos[line][0] &&
			    xpos < circle_pos[line][1])
				mvaddch(line, xpos, ' ');
		}
	}

	/* Add yellow segment at bottom. */
	for (line = 12 * grid_unit; line < y_limit; line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_YELLOW));
		else
    			attrset(A_REVERSE);


		for (col = circle_pos[line][0]; col <= circle_pos[line][1];
		    col++)
			mvaddch(line, col, ' ');

		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_RED));
		else
    			attrset(A_NORMAL);

		for (col = roundf((6 * grid_unit * 2)); col <
		    roundf((7 * grid_unit * 2)); col++) {
				xpos = col + circle_pos[y_limit / 2][0];
				if (xpos >= circle_pos[line][0] &&
				    xpos < circle_pos[line][1])
					mvaddch(line, xpos, ' ');
		}
	}

	if (colourOK)
    		attrset(COLOR_PAIR(COLOR_BLACK));
	else
    		attrset(A_NORMAL);

	for (line = 6 * grid_unit; line <= (7 * grid_unit) + 1; line++) {
		if (colourOK)
    			attrset(COLOR_PAIR(COLOR_BLACK));
		else
    			attrset(A_NORMAL);

		col = x_limit / 2;
		if (line != a_axis) {
			mvaddch(line, col - 1, ' ');
			mvaddch(line, col, 120 | A_ALTCHARSET);
			mvaddch(line, col + 1, ' ');
		}
	}

	line = y_limit / 2;
	for (col = 1; col < x_limit; col = col + grid_x) {
		xpos = col;
		while (xpos < col + grid_x - 1) {
			if (xpos >= circle_pos[line][0]
			    && xpos < circle_pos[line][1])
				mvaddch(line, xpos, 113 | A_ALTCHARSET);
			xpos++;
		}
		if (xpos >= circle_pos[line][0] && xpos < circle_pos[line][1])
			mvaddch(line, xpos, 110 | A_ALTCHARSET);
	}

	line = y_limit / 2;
	col = x_limit / 2;
	mvaddch(line, col, 110 | A_ALTCHARSET);
	mvaddch(line, col - 1, 113 | A_ALTCHARSET);
	mvaddch(line, col + 1, 113 | A_ALTCHARSET);

	refresh();

	getch();

	endwin();

	return EXIT_SUCCESS;
}