fissh

termios terminal aquarium. demo at ssh://fish@kloet.net
Download | Log | Files | Refs

main.cpp (3459B)

      1 #include "Aquarium.h"
      2 #include "Config.h"
      3 #include <chrono>
      4 #include <iostream>
      5 #include <thread>
      6 
      7 #ifdef __OpenBSD__
      8 #include <unistd.h>
      9 #endif
     10 
     11 // Forward declaration
     12 bool parseArguments(int argc, char *argv[]);
     13 
     14 int main(int argc, char *argv[]) {
     15   // Parse command line arguments
     16   if (!parseArguments(argc, argv)) {
     17     return 1; // Exit if parsing failed or help was shown
     18   }
     19 
     20   // Print configuration if debug mode is enabled
     21   if (g_config.debug_mode) {
     22     std::cout << "Configuration:\n";
     23     std::cout << "  Fish count: "
     24               << (g_config.initial_fish_count == -1
     25                       ? "auto"
     26                       : std::to_string(g_config.initial_fish_count))
     27               << "\n";
     28     std::cout << "  Seaweed count: "
     29               << (g_config.initial_seaweed_count == -1
     30                       ? "auto"
     31                       : std::to_string(g_config.initial_seaweed_count))
     32               << "\n";
     33     std::cout << "  Max bubbles: " << g_config.max_bubbles << "\n";
     34     std::cout << "  Frame delay: " << g_config.frame_delay_ms << "ms\n";
     35     std::cout << "  Big entities: "
     36               << (g_config.enable_big_entities ? "enabled" : "disabled")
     37               << "\n";
     38     std::cout << "  Bubbles: "
     39               << (g_config.enable_bubbles ? "enabled" : "disabled") << "\n";
     40     std::cout << "  Colors: " << (g_config.use_colors ? "enabled" : "disabled")
     41               << "\n";
     42     std::cout << "  Bold text: " << (g_config.use_bold ? "enabled" : "disabled")
     43               << "\n";
     44     std::cout << "  Max entities: " << g_config.max_entities << "\n";
     45     std::cout << "Press any key to continue...\n";
     46     std::cin.get();
     47   }
     48 
     49   Aquarium &aquarium = Aquarium::getInstance();
     50 
     51 #ifdef __OpenBSD__
     52   if (pledge("stdio tty", NULL) == -1) {
     53     perror("pledge");
     54     return 1;
     55   }
     56 #endif
     57 
     58   // Initialize the aquarium display
     59   aquarium.resize(); // Setup initial entities
     60 
     61   // Variables for FPS calculation
     62   auto last_time = std::chrono::steady_clock::now();
     63   int frame_count = 0;
     64   double fps = 0.0;
     65 
     66   // Main game loop
     67   while (true) {
     68     auto frame_start = std::chrono::steady_clock::now();
     69 
     70     int input = aquarium.checkInput();
     71     if (input == 'q' || input == 'Q' || input == 27) { // ESC key
     72       break;
     73     }
     74 
     75     // Toggle debug info with 'd' key
     76     if (input == 'd' || input == 'D') {
     77       g_config.show_fps = !g_config.show_fps;
     78       g_config.show_entity_count = !g_config.show_entity_count;
     79     }
     80 
     81     if (aquarium.checkResize()) {
     82       aquarium.resize();
     83     }
     84 
     85     aquarium.redraw();
     86 
     87     // Calculate FPS
     88     if (g_config.show_fps) {
     89       ++frame_count;
     90       auto current_time = std::chrono::steady_clock::now();
     91       auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
     92                          current_time - last_time)
     93                          .count();
     94 
     95       if (elapsed >= 1000) { // Update FPS every second
     96         fps = (frame_count * 1000.0) / elapsed;
     97         frame_count = 0;
     98         last_time = current_time;
     99       }
    100     }
    101 
    102     // Sleep for configured frame delay
    103     auto frame_end = std::chrono::steady_clock::now();
    104     auto frame_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
    105         frame_end - frame_start);
    106     auto sleep_duration =
    107         std::chrono::milliseconds(g_config.frame_delay_ms) - frame_duration;
    108 
    109     if (sleep_duration > std::chrono::milliseconds(0)) {
    110       std::this_thread::sleep_for(sleep_duration);
    111     }
    112   }
    113 
    114   return 0;
    115 }