code / nuke

   1 /**
   2   * A program to nuke files from orbit.
   3   */
   4 #include "colors.h"
   5 #include "explosion.h"
   6 #include "globe.h"
   7 #include <curses.h>
   8 #include <dirent.h>
   9 #include <errno.h>
  10 #define __USE_XOPEN_EXTENDED
  11 #include <ftw.h>
  12 #include <math.h>
  13 #include <poll.h>
  14 #include <signal.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18 
  19 #define MAX_FILES 2048
  20 #define NUM_FRAMES 100
  21 // 30 FPS:
  22 #define FRAME_USEC 33333
  23 
  24 static int color_ramp1[] = {1,1,1,2,2,2,3,3,3,1,1, -1};
  25 static int bold_ramp1[] =  {1,1,0,1,0,0,1,0,0,0,0, -1};
  26 static int color_ramp2[] = {1,1,1,1,2,2,2,2,2,3,3,3,3,3,1,1,1,1,1,1, -1};
  27 static int bold_ramp2[] =  {1,1,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0, -1};
  28 
  29 static void sighandler(int sig) {
  30     (void)sig;
  31     curs_set(1);
  32     endwin();
  33     exit(EXIT_FAILURE);
  34 }
  35 
  36 static int remove_callback(const char *path, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
  37 {
  38         int rv = remove(path);
  39         if (rv) perror(path);
  40         return rv;
  41 }
  42 
  43 static void add_file(char *name, char ***files, int *size, int *capacity)
  44 {
  45     // Prevent from taking too long
  46     if (*size > MAX_FILES) return;
  47     if (*size == *capacity) {
  48         *capacity *= 2;
  49         *files = realloc(*files, sizeof(char*) * (*capacity));
  50     }
  51     if (*size == MAX_FILES)
  52         (*files)[*size] = strdup("...too many to list...");
  53     else
  54         (*files)[*size] = strdup(name);
  55     (*size)++;
  56 }
  57 
  58 int main(int argc, char *argv[])
  59 {
  60     if (argc > 1 && strcmp(argv[1], "--help") == 0) {
  61         printf("nuke: Nuke files from orbit.\nUsage: nuke [files...]\n");
  62         return EXIT_SUCCESS;
  63     }
  64 
  65     char *failure_message = "nothing was deleted";
  66 
  67     int rows,cols;
  68     int delay=1E5;
  69 
  70     int capacity = 32, num_files = 0;
  71     char **files = malloc(sizeof(char*)*capacity);
  72     for (int i = 1; i < argc; i++) {
  73         add_file(argv[i], &files, &num_files, &capacity);
  74     }
  75 
  76     /* Initialize ncurses and get window dimensions */
  77     //initscr();
  78     char* term_type = getenv("TERM");
  79     if (term_type == NULL || *term_type == '\0') {
  80         term_type = "unknown";
  81     }
  82     FILE* term_in = fopen("/dev/tty", "r");
  83     if (term_in == NULL) {
  84         perror("fopen(/dev/tty)");
  85         exit(EXIT_FAILURE);
  86     }
  87     SCREEN* main_screen = newterm(term_type, stdout, term_in);
  88     set_term(main_screen);
  89 
  90     signal(SIGINT, sighandler);
  91 
  92     size_t buf_chunk = 1024;
  93     size_t buf_size = buf_chunk, buf_i = 0;
  94     char *outbuf = calloc(buf_size, sizeof(char));
  95 
  96     { // Read stdin if anything was piped in
  97         struct pollfd desc;
  98         desc.fd = STDIN_FILENO;
  99         desc.events = POLLIN;
 100         int ret = poll(&desc, 1, 50);
 101         if (ret > 0) {
 102             char *line = NULL;
 103             size_t linebuf_size;
 104             ssize_t line_len;
 105             while ((line_len = getline(&line, &linebuf_size, stdin)) >= 0) {
 106                 if (line[line_len-1] == '\n')
 107                     line[--line_len] = '\0';
 108                 if (line_len > 0)
 109                     add_file(line, &files, &num_files, &capacity);
 110             }
 111         }
 112     }
 113 
 114     int testing = 0;
 115     if (num_files == 0) {
 116         add_file("<testing grounds>", &files, &num_files, &capacity);
 117         testing = 1;
 118     }
 119 
 120     start_color();
 121     init_pair(WHITE, COLOR_WHITE, COLOR_BLACK);
 122     init_pair(YELLOW, COLOR_YELLOW, COLOR_BLACK);
 123     init_pair(RED, COLOR_RED, COLOR_BLACK);
 124     init_pair(BLUE, COLOR_BLUE, COLOR_BLACK);
 125     init_pair(GREEN, COLOR_GREEN, COLOR_BLACK);
 126     init_pair(BLACK, COLOR_BLACK, COLOR_BLACK);
 127     init_pair(WHITE_BG, COLOR_BLACK, COLOR_WHITE);
 128     init_pair(BLACK_ON_RED, COLOR_BLACK, COLOR_RED);
 129     init_pair(BLACK_ON_GREEN, COLOR_BLACK, COLOR_GREEN);
 130     
 131     for (int i = 0; color_ramp1[i] >= 0; i++)
 132         color_ramp1[i] = COLOR_PAIR(color_ramp1[i]) | (bold_ramp1[i] ? A_BOLD : 0);
 133     for (int i = 0; color_ramp2[i] >= 0; i++)
 134         color_ramp2[i] = COLOR_PAIR(color_ramp2[i]) | (bold_ramp2[i] ? A_BOLD : 0);
 135 
 136     getmaxyx(stdscr,rows,cols);
 137 
 138     curs_set(0); /* hide text cursor */
 139     noecho();
 140     keypad(stdscr, 1);
 141 
 142     // First frame
 143     int max_line = 0;
 144     for (int f = 0; f < num_files; f++) {
 145         int len = strlen(files[f]);
 146         if (len > max_line) max_line = len;
 147     }
 148 
 149     erase();
 150     int padwidth = max_line < cols*3/4 ? max_line : cols*3/4;
 151     int padheight = num_files < rows*3/4 ? num_files : rows*3/4;
 152     int padframer = rows/2-padheight/2-1;
 153     int padframec = cols/2-padwidth/2-1;
 154     WINDOW *padframe = newwin(padheight+2, padwidth+2, padframer, padframec);
 155     if (!padframe) {
 156         failure_message = "Couldn't create pad frame";
 157         goto exit_failure;
 158     }
 159     wattron(padframe, COLOR_PAIR(YELLOW) | A_BOLD);
 160     box(padframe, 0, 0);
 161     WINDOW *pad = newpad(padheight, max_line);
 162     if (!pad) {
 163         failure_message = "Couldn't create pad";
 164         goto exit_failure;
 165     }
 166 
 167     /* Display confirmation */
 168     attron(COLOR_PAIR(BLACK_ON_RED));
 169     char *description = num_files == 1 ? "        TARGET:       " :  "        TARGETS:      ";
 170     mvprintw(padframer-2, cols/2 - strlen(description)/2, "%s", description);
 171     attron(COLOR_PAIR(BLACK_ON_RED) | A_BLINK);
 172     const char confirm[] =     "    FIRE NUKE? y/n    ";
 173     mvprintw(padframer+padheight+3, cols/2 - strlen(confirm)/2, "%s", confirm);
 174     attroff(COLOR_PAIR(BLACK_ON_RED) | A_BLINK);
 175     refresh();
 176 
 177     //immedok(pad, 1);
 178     int scrollx = 0, scrolly = 0;
 179 
 180     timeout(10);
 181     while (1) {
 182         // Draw scroll bar
 183         if (padheight < num_files) {
 184             mvaddch(padframer, padframec+padwidth+2, ACS_UARROW);
 185             mvaddch(padframer+padheight+1, padframec+padwidth+2, ACS_DARROW);
 186             for (int i = 1; i <= padheight; i++)
 187                 mvaddch(padframer+i, padframec+padwidth+2, ACS_VLINE);
 188             for (int i = scrolly*padheight/num_files; i <= scrolly*padheight/num_files+padheight*padheight/num_files; i++)
 189                 mvaddch(padframer+1+i, padframec+padwidth+2, ACS_CKBOARD);
 190         }
 191         box(padframe, 0, 0);
 192         if (wrefresh(padframe) == ERR) goto exit_failure;
 193         // Redo this each time so that pad doesn't have to hold everything in memory
 194         werase(pad);
 195         for (int f = scrolly; f < scrolly+padheight; f++) {
 196             mvwprintw(pad,f-scrolly,0,"%s",files[f]);
 197         }
 198         if (prefresh(pad, 0, scrollx, padframer+1, padframec+1, padframer+padheight, padframec+padwidth) == ERR)
 199             goto exit_failure;
 200         //prefresh(pad, scrolly, scrollx, 1, 1, 1+padheight, 1+padwidth);
 201         //prefresh(pad, scrolly, scrollx, rows/2-padheight/2, cols/2-padwidth/2, rows/2+padheight/2, cols/2+padwidth/2);
 202         refresh();
 203       get_input:
 204         switch (getch()) {
 205             case 'y':
 206                 goto do_the_nuking;
 207             case 'n': case 'q': case 27:
 208                 goto exit_failure;
 209             case KEY_DOWN: case 'j': case ' ':
 210                 scrolly++;
 211                 break;
 212             case KEY_UP: case 'k':
 213                 scrolly--;
 214                 break;
 215             case KEY_RIGHT: case 'l':
 216                 scrollx++;
 217                 break;
 218             case KEY_LEFT: case 'h':
 219                 scrollx--;
 220                 break;
 221             case 'J': case KEY_NPAGE:
 222                 scrolly += num_files/20+1;
 223                 break;
 224             case 'K': case KEY_PPAGE:
 225                 scrolly -= num_files/20+1;
 226                 break;
 227             case KEY_SRIGHT: case 'L':
 228                 scrollx += 10;
 229                 break;
 230             case KEY_SLEFT: case 'H':
 231                 scrollx -= 10;
 232                 break;
 233             case KEY_HOME: case 'g':
 234                 scrolly = 0;
 235                 break;
 236             case KEY_END: case 'G':
 237                 scrolly = num_files-padheight;
 238                 break;
 239             default:
 240                 goto get_input;
 241         }
 242         if (scrolly < 0) scrolly = 0;
 243         if (scrolly > num_files-padheight) scrolly = num_files-padheight;
 244         if (scrollx < 0) scrollx = 0;
 245         if (scrollx > max_line-padwidth) scrollx = max_line-padwidth;
 246     }
 247 
 248     do_the_nuking: ;
 249 
 250     double zoom = .8; // percent of viewport globe will fill
 251 
 252     const double targeting_time = 2.5;
 253     const double anticipation = 0.5;
 254     const double firing_time = 1.0;
 255     const double nuking_time = .5;
 256     const double aftermath = 100.0;
 257 
 258     int f = 0;
 259     int targetr, targetc;
 260     double t = 0.0;
 261     for (; t < targeting_time + anticipation + firing_time; t += 1./30.) {
 262         erase();
 263         draw_stars(t);
 264         draw_globe(t, zoom);
 265         if (get_target_pos(t, zoom, &targetr, &targetc)) {
 266             // If visible draw '*' on globe
 267             attron(COLOR_PAIR(YELLOW));
 268             mvaddch(targetr,targetc, '*' | A_BOLD);
 269             attroff(COLOR_PAIR(YELLOW));
 270         }
 271         draw_clouds(t, zoom);
 272         // Draw crosshair
 273         double wobble = t > targeting_time ? 0. : targeting_time - t;
 274         int r = targetr, c = targetc;
 275         if (wobble > .01) {
 276             r = mix(r, rows*hillnoise(784,5.*t), wobble);
 277             c = mix(c, cols*hillnoise(-784,5.*t), wobble);
 278         }
 279         int attr = COLOR_PAIR(RED);
 280         attron(attr);
 281         mvaddch(r-1,c-2,ACS_ULCORNER | A_BOLD);
 282         mvaddch(r-1,c-1,ACS_HLINE | A_BOLD);
 283         mvaddch(r-1,c+1,ACS_HLINE | A_BOLD);
 284         mvaddch(r-1,c+2,ACS_URCORNER | A_BOLD);
 285         mvaddch(r+1,c+2,ACS_LRCORNER | A_BOLD);
 286         mvaddch(r+1,c+1,ACS_HLINE | A_BOLD);
 287         mvaddch(r+1,c-1,ACS_HLINE | A_BOLD);
 288         mvaddch(r+1,c-2,ACS_LLCORNER | A_BOLD);
 289         mvaddch(r,c,'X' | A_BOLD);
 290         attroff(attr);
 291 
 292         // Draw label
 293         if (get_target_pos(t, zoom, &targetr, &targetc)) {
 294             attron(COLOR_PAIR(RED));
 295             mvaddch(targetr-1,targetc+1,'/');
 296             attroff(COLOR_PAIR(RED));
 297             attron(COLOR_PAIR(BLACK_ON_RED));
 298             if (num_files <= 0) {
 299                 mvprintw(targetr-2,targetc+2,"%s", "testing grounds");
 300             } else {
 301                 for (int t=0; t < num_files; t++) {
 302                     mvprintw(targetr-2-t,targetc+2,"%s", files[num_files-t-1]);
 303                 }
 304             }
 305             attroff(COLOR_PAIR(BLACK_ON_RED));
 306         }
 307 
 308         // Draw nuke
 309         if (t > targeting_time + anticipation) {
 310             double k = (t-targeting_time-anticipation)/firing_time;
 311             int nuker = mix(rows, targetr, k), nukec = mix(cols/2, targetc, k);
 312             attron(COLOR_PAIR(WHITE) | A_BOLD);
 313             mvaddch(nuker, nukec, "A^' "[(int)(k*4.)]);
 314             attroff(COLOR_PAIR(WHITE) | A_BOLD);
 315 
 316             // Draw nuke label
 317             attron(COLOR_PAIR(RED));
 318             mvaddch(nuker-1,nukec-1,'\\');
 319             attroff(COLOR_PAIR(RED));
 320             attron(COLOR_PAIR(BLACK_ON_RED));
 321             mvprintw(nuker-2,nukec-2-5,"%0.3f", (targeting_time + anticipation + firing_time)-t);
 322             attroff(COLOR_PAIR(BLACK_ON_RED));
 323         }
 324 
 325         refresh();
 326 
 327         // Check for input
 328         int ch = getch();
 329         if (ch == 'q' || ch == 27) {
 330             if (t <= targeting_time + anticipation) {
 331                 goto exit_failure;
 332             } else {
 333                 goto exit_success;
 334             }
 335         }
 336         usleep(FRAME_USEC);
 337     }
 338 
 339     for (int i=0; i<100; i++) {
 340         draw_explosion(i, targetc, targetr);
 341         refresh();
 342         /* Quit early? */
 343         int ch = getch();
 344         if (ch == 'q' || ch == 27) {
 345             goto exit_success;
 346         }
 347         if (i == 0)
 348             usleep(8*FRAME_USEC); // flash for 8 frames
 349         else
 350             usleep(FRAME_USEC);
 351     }
 352     t += nuking_time;
 353 
 354     for (; t < targeting_time + anticipation + firing_time + nuking_time + aftermath; t += 1./30.) {
 355         erase();
 356         draw_stars(t);
 357         draw_globe(t, zoom);
 358         // Draw crater
 359         if (get_target_pos(t, zoom, &targetr, &targetc)) {
 360             attron(COLOR_PAIR(BLACK) | A_BOLD);
 361             for (int i = 31; i >= 0; i--) {
 362                 double rad = 4./31.*i;
 363                 double a = i*2*M_PI*GOLDEN_RATIO;
 364                 int r = targetr+(int)(rad*sin(a)/2), c = targetc+(int)(rad*cos(a));
 365                 if ((r-rows/2)*(r-rows/2) + (c/2-cols/4)*(c/2-cols/4) <= (zoom*rows/2)*(zoom*rows/2))
 366                     mvaddch(r, c, " #*."[i*4/31]);
 367             }
 368             attroff(COLOR_PAIR(BLACK) | A_BOLD);
 369             /*
 370             for (double =target_lat
 371             mvprintw(targetr-1,targetc-1,"****");
 372             mvprintw(targetr,targetc-2, "**  **");
 373             mvprintw(targetr+1,targetc-1,"****");
 374             */
 375         }
 376         draw_clouds(t, zoom);
 377         if (get_target_pos(t, zoom, &targetr, &targetc)) {
 378             // Draw label
 379             attron(COLOR_PAIR(GREEN));
 380             mvaddch(targetr-1,targetc+1,'/');
 381             attroff(COLOR_PAIR(GREEN));
 382             attron(COLOR_PAIR(BLACK_ON_GREEN));
 383             mvprintw(targetr-2,targetc+2," DELETED ");
 384             attroff(COLOR_PAIR(BLACK_ON_GREEN));
 385         }
 386 
 387         attron(COLOR_PAIR(BLACK_ON_GREEN) | A_BLINK);
 388         const char *any_key = "    PRESS ANY KEY TO EXIT    ";
 389         mvprintw(rows-(1.-zoom)*rows/4, cols/2-strlen(any_key)/2, any_key);
 390         attroff(COLOR_PAIR(BLACK_ON_GREEN) | A_BLINK);
 391 
 392         refresh();
 393         if (getch() != -1)
 394             goto exit_success;
 395         usleep(FRAME_USEC);
 396     }
 397     
 398   exit_success:
 399     curs_set(1); /* unhide cursor */
 400     endwin(); /* Exit ncurses */
 401     int exit_status = EXIT_SUCCESS;
 402     if (!testing) {
 403         for (int i = 0; i < num_files; i++) {
 404             int failure;
 405             DIR *dir;
 406             if (!(dir = opendir(files[i]))) {
 407                 failure = remove(files[i]);
 408             } else {
 409                 closedir(dir);
 410                 failure = nftw(files[i], remove_callback, 64, FTW_DEPTH | FTW_PHYS);
 411             }
 412             if (!failure) {
 413                 printf("%s\n", files[i]);
 414             } else {
 415                 printf("Error: unable to delete %s (%s)\n", files[i], strerror(errno));
 416                 exit_status = EXIT_FAILURE;
 417             }
 418         }
 419     }
 420     return exit_status;
 421 
 422   exit_failure:
 423     curs_set(1); /* unhide cursor */
 424     endwin(); /* Exit ncurses */
 425     printf("%s\n",failure_message);
 426     return EXIT_FAILURE;
 427 }