277 lines
7.8 KiB
C
277 lines
7.8 KiB
C
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <ncurses.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <math.h>
|
|
|
|
uint16_t Hole_Div = 40;
|
|
uint16_t SCR_X;
|
|
uint16_t SCR_Y;
|
|
#define FPS (60)
|
|
char blank_char = 32;
|
|
char wall_char = 35;
|
|
char goal_char = 71;
|
|
char player_char = 80;
|
|
char bullet_char = 120;
|
|
char inchar = ' ';
|
|
uint16_t blank_color = 0;
|
|
uint16_t wall_color = 1;
|
|
uint16_t goal_color = 2;
|
|
uint16_t player_color = 3;
|
|
uint16_t border_color = 4;
|
|
uint16_t bullet1_color = 5;
|
|
uint16_t bullet2_color = 5;
|
|
char letter = ' ';
|
|
struct Object {
|
|
uint16_t x;
|
|
uint16_t y;
|
|
char letter;
|
|
uint16_t color;
|
|
uint8_t dir;
|
|
};
|
|
struct Bullet {
|
|
uint16_t x;
|
|
uint16_t y;
|
|
uint8_t dir;
|
|
uint8_t color;
|
|
};
|
|
uint16_t bulletptr = 0;
|
|
uint16_t player_x = 0;
|
|
uint16_t player_y = 0;
|
|
uint16_t goal_x = 0;
|
|
uint16_t goal_y = 0;
|
|
uint16_t rng_tmp = 0;
|
|
uint16_t orient = 0;
|
|
uint16_t inputs_tmp = 0;
|
|
struct Object * rendered;
|
|
struct Bullet * bullets;
|
|
char * playfield;
|
|
int randomInt(int lower, int upper) {
|
|
return rand() % (upper - lower + 1) + lower;
|
|
}
|
|
void generate_maze() {
|
|
//fill playfield with blank
|
|
for (uint16_t y = 0; y < SCR_Y; y++) {
|
|
for (uint16_t x = 0; x < SCR_X; x++) {
|
|
playfield[y * SCR_X + x] = blank_char;
|
|
}
|
|
}
|
|
//fill every other row with walls
|
|
for (uint16_t y = 0; y < SCR_Y; y += 2) {
|
|
for (uint16_t x = 0; x < SCR_X; x++) {
|
|
playfield[y * SCR_X + x] = wall_char;
|
|
}
|
|
}
|
|
//punch holes in the walls
|
|
for (uint16_t y = 0; y < SCR_Y; y++) {
|
|
//punch holes in the walls depending on the SCR_X
|
|
for (uint16_t ix = 0; ix < ((SCR_X - (SCR_X % Hole_Div)) / Hole_Div); ix += 1) {
|
|
rng_tmp = randomInt(1, SCR_X);
|
|
|
|
playfield[y * SCR_X + rng_tmp] = blank_char;
|
|
}
|
|
if (orient == 0) {
|
|
if (y == 0) {
|
|
|
|
playfield[y * SCR_X + rng_tmp] = goal_char;
|
|
goal_x = rng_tmp;
|
|
goal_y = y;
|
|
}
|
|
if (y == SCR_Y - 1) {
|
|
|
|
playfield[y * SCR_X + rng_tmp] = player_char;
|
|
player_x = rng_tmp;
|
|
player_y = y;
|
|
}
|
|
} else {
|
|
if (y == SCR_Y - 1) {
|
|
|
|
playfield[y * SCR_X + rng_tmp] = goal_char;
|
|
goal_x = rng_tmp;
|
|
goal_y = y;
|
|
}
|
|
if (y == 0) {
|
|
|
|
playfield[y * SCR_X + rng_tmp] = player_char;
|
|
player_x = rng_tmp;
|
|
player_y = y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void render_maze() {
|
|
//fill rendered with blank
|
|
for (uint16_t y = 0; y < SCR_Y; y++) {
|
|
for (uint16_t x = 0; x < SCR_X; x++) {
|
|
|
|
rendered[y * SCR_X + x].letter = blank_char;
|
|
rendered[y * SCR_X + x].color = blank_color;
|
|
rendered[y * SCR_X + x].x = x;
|
|
rendered[y * SCR_X + x].y = y;
|
|
}
|
|
}
|
|
for (uint16_t y = 0; y < SCR_Y; y++) {
|
|
for (uint16_t x = 0; x < SCR_X; x++) {
|
|
|
|
letter = playfield[(y) * SCR_X + (x)];
|
|
|
|
rendered[(y) * SCR_X + (x)].letter = letter;
|
|
|
|
rendered[(y) * SCR_X + (x)].x = x;
|
|
|
|
rendered[(y) * SCR_X + (x)].y = y;
|
|
if (letter == goal_char) {
|
|
|
|
rendered[(y) * SCR_X + (x)].color = goal_color;
|
|
} else if (letter == player_char) {
|
|
|
|
rendered[(y) * SCR_X + (x)].color = player_color;
|
|
} else if (letter == blank_char) {
|
|
|
|
rendered[(y) * SCR_X + (x)].color = blank_color;
|
|
} else if (letter == wall_char) {
|
|
|
|
rendered[(y) * SCR_X + (x)].color = wall_color;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void draw_maze() {
|
|
for (uint16_t y = 0; y < SCR_Y; y++) {
|
|
for (uint16_t x = 0; x < SCR_X; x++) {
|
|
|
|
attron(COLOR_PAIR(rendered[(y) * SCR_X + (x)].color));
|
|
|
|
mvaddch(y, x, rendered[(y) * SCR_X + (x)].letter);
|
|
|
|
attroff(COLOR_PAIR(rendered[(y) * SCR_X + (x)].color));
|
|
}
|
|
}
|
|
refresh();
|
|
}
|
|
void init() {
|
|
initscr();
|
|
//get screen size
|
|
getmaxyx(stdscr, SCR_Y, SCR_X);
|
|
playfield = malloc(sizeof(char) * SCR_Y * SCR_X);
|
|
rendered = malloc(sizeof(struct Object) * (SCR_X) * (SCR_Y));
|
|
bullets = malloc(sizeof(struct Bullet) * (SCR_X) * (SCR_Y));
|
|
noecho();
|
|
nodelay(stdscr, TRUE);
|
|
start_color();
|
|
init_pair(blank_color, COLOR_WHITE, COLOR_WHITE);
|
|
init_pair(wall_color, COLOR_BLACK, COLOR_RED);
|
|
init_pair(goal_color, COLOR_BLACK, COLOR_GREEN);
|
|
init_pair(player_color, COLOR_BLACK, COLOR_YELLOW);
|
|
init_pair(border_color, COLOR_WHITE, COLOR_BLUE);
|
|
init_pair(bullet1_color, COLOR_BLACK, COLOR_YELLOW);
|
|
init_pair(bullet2_color, COLOR_BLACK, COLOR_GREEN);
|
|
attron(COLOR_PAIR(blank_color));
|
|
clear();
|
|
srand(time(NULL));
|
|
}
|
|
int keyinput() {
|
|
inchar = getch();
|
|
if (inchar == 'q') {
|
|
return 1;
|
|
}
|
|
if (inchar == 'w') {
|
|
//if (playfield[player_y - 1][player_x] == blank_char){
|
|
if (player_y > 0 && playfield[(player_y - 1) * SCR_X + player_x] == blank_char) {
|
|
|
|
playfield[(player_y) * SCR_X + player_x] = blank_char;
|
|
player_y--;
|
|
|
|
playfield[(player_y) * SCR_X + player_x] = player_char;
|
|
//}else if (playfield[player_y - 1][player_x] == goal_char){
|
|
} else if (playfield[(player_y - 1) * SCR_X + player_x] == goal_char) {
|
|
return 2;
|
|
}
|
|
}
|
|
if (inchar == 'a') {
|
|
//if (playfield[player_y][player_x - 1] == blank_char){
|
|
if (player_x > 0 && playfield[(player_y) * SCR_X + (player_x - 1)] == blank_char) {
|
|
|
|
playfield[(player_y) * SCR_X + player_x] = blank_char;
|
|
player_x--;
|
|
|
|
playfield[(player_y) * SCR_X + player_x] = player_char;
|
|
}
|
|
//else if (playfield[player_y][player_x - 1] == goal_char){
|
|
else if (playfield[(player_y) * SCR_X + (player_x - 1)] == goal_char) {
|
|
return 2;
|
|
}
|
|
}
|
|
if (inchar == 's') {
|
|
//if (playfield[player_y + 1][player_x] == blank_char){
|
|
if (player_x < SCR_X - 1 && playfield[(player_y + 1) * SCR_X + player_x] == blank_char) {
|
|
playfield[(player_y) * SCR_X + player_x] = blank_char;
|
|
player_y++;
|
|
playfield[(player_y) * SCR_X + player_x] = player_char;
|
|
// }else if (playfield[player_y + 1][player_x] == goal_char){
|
|
} else if (playfield[(player_y + 1) * SCR_X + player_x] == goal_char) {
|
|
return 2;
|
|
}
|
|
|
|
}
|
|
if (inchar == 'd') {
|
|
// if (playfield[player_y][player_x + 1] == blank_char){
|
|
if (player_x < SCR_X - 1 && playfield[(player_y) * SCR_X + (player_x + 1)] == blank_char) {
|
|
playfield[(player_y) * SCR_X + player_x] = blank_char;
|
|
player_x++;
|
|
playfield[(player_y) * SCR_X + player_x] = player_char;
|
|
}
|
|
//else if (playfield[player_y][player_x + 1] == goal_char){
|
|
else if (playfield[(player_y) * SCR_X + (player_x + 1)] == goal_char) {
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
int main(int argc, char * argv[]) {
|
|
init();
|
|
//parse the command line arguments for width and height
|
|
if (argc == 3) {
|
|
SCR_X = atoi(argv[1]);
|
|
SCR_Y = atoi(argv[2]);
|
|
}
|
|
if (argc == 2) {
|
|
Hole_Div = atoi(argv[1]);
|
|
}
|
|
if (argc == 4) {
|
|
SCR_X = atoi(argv[1]);
|
|
SCR_Y = atoi(argv[2]);
|
|
Hole_Div = atoi(argv[3]);
|
|
}
|
|
generate_maze();
|
|
render_maze();
|
|
draw_maze();
|
|
while (1) {
|
|
inputs_tmp = keyinput();
|
|
if (inputs_tmp == 1) {
|
|
break;
|
|
}
|
|
if (inputs_tmp == 2) {
|
|
if (orient == 0) {
|
|
orient = 1;
|
|
} else {
|
|
orient = 0;
|
|
}
|
|
generate_maze();
|
|
}
|
|
render_maze();
|
|
draw_maze();
|
|
usleep(round(1000000 / FPS));
|
|
}
|
|
endwin();
|
|
free(playfield);
|
|
free(rendered);
|
|
return 0;
|
|
} |