fissh

Aquarium.cpp (11256B)

---

 #include "Aquarium.h"
 #include "../core/Config.h"
 #include "../entities/Bubble.h"
 #include "../entities/Castle.h"
 #include "../entities/Fish.h"
 #include "../entities/SeaMonster.h"
 #include "../entities/Seaweed.h"
 #include "../entities/Ship.h"
 #include "../entities/Waterline.h"
 #include "../entities/Whale.h"
 #include <algorithm>
 #include <chrono>
 #include <cstdio>
 #include <cstring>
 #include <iomanip>
 #include <iostream>
 #include <signal.h>
 #include <sstream>
 #include <sys/ioctl.h>
 #include <termios.h>
 #include <unistd.h>
 
 // ANSI color codes
 namespace ANSI {
 const char *RESET = "\033[0m";
 const char *BOLD = "\033[1m";
 const char *CLEAR_SCREEN = "\033[2J";
 const char *CURSOR_HOME = "\033[H";
 const char *HIDE_CURSOR = "\033[?25l";
 const char *SHOW_CURSOR = "\033[?25h";
 
 // Colors (foreground)
 const char *BLACK = "\033[30m";
 const char *RED = "\033[31m";
 const char *GREEN = "\033[32m";
 const char *YELLOW = "\033[33m";
 const char *BLUE = "\033[34m";
 const char *MAGENTA = "\033[35m";
 const char *CYAN = "\033[36m";
 const char *WHITE = "\033[37m";
 // Colors (background)
 const char *BG_BLACK = "\033[40m";
 const char *RESET_BLACK_BG = "\033[0;40m";
 
 // Move cursor to position
 std::string moveTo(int row, int col) {
   char buffer[32];
   snprintf(buffer, sizeof(buffer), "\033[%d;%dH", row + 1, col + 1);
   return std::string(buffer);
 }
 } // namespace ANSI
 
 // Global terminal state
 static struct termios original_termios;
 static bool termios_saved = false;
 
 // Signal handler for cleanup
 void cleanup_terminal(int sig) {
   if (termios_saved) {
     tcsetattr(STDIN_FILENO, TCSANOW, &original_termios);
   }
   printf("%s%s", ANSI::SHOW_CURSOR, ANSI::RESET);
   fflush(stdout);
   if (sig != 0) {
     exit(sig);
   }
 }
 
 Aquarium::Aquarium() {
   // Save original terminal settings
   if (tcgetattr(STDIN_FILENO, &original_termios) == 0) {
     termios_saved = true;
   }
 
   // Set up signal handlers for cleanup
   signal(SIGINT, cleanup_terminal);
   signal(SIGTERM, cleanup_terminal);
   signal(SIGQUIT, cleanup_terminal);
 
   // Set terminal to raw mode
   struct termios raw = original_termios;
   raw.c_lflag &= ~(ECHO | ICANON);
   raw.c_iflag &= ~(IXON | ICRNL);
   raw.c_oflag &= ~(OPOST);
   raw.c_cc[VMIN] = 0;  // Non-blocking read
   raw.c_cc[VTIME] = 1; // 100ms timeout
 
   tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
 
   // Initialize display
   printf("%s%s%s%s", ANSI::CLEAR_SCREEN, ANSI::CURSOR_HOME, ANSI::HIDE_CURSOR,
          ANSI::BG_BLACK);
   fflush(stdout);
 
   // Get terminal size
   getTerminalSize();
 
   currentFrame.assign(height, std::vector<Cell>(width));
   previousFrame.assign(height, std::vector<Cell>(width));
 
   if (!colorLookupInitialized) {
     initColorLookup();
     colorLookupInitialized = true;
   }
 }
 
 void Aquarium::getTerminalSize() {
   struct winsize ws;
   if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0) {
     height = ws.ws_row;
     width = ws.ws_col;
   } else {
     cleanup_terminal(0);
     std::cerr << "Error: Unable to determine terminal size.\n";
     std::exit(1);
   }
 }
 
 void Aquarium::ensureEntitiesSorted() {
   if (entities_need_sorting) {
     std::sort(entities.begin(), entities.end(),
               [](const auto &a, const auto &b) {
                 int layerA = a->getPreferredLayer();
                 int layerB = b->getPreferredLayer();
                 if (layerA != layerB)
                   return layerA < layerB;
                 return a->getId() < b->getId();
               });
     entities_need_sorting = false;
   }
 }
 
 void Aquarium::redraw() {
   clearCurrentFrame();
 
   if (g_config.enable_big_entities) {
     ensureBigEntityExists();
   }
 
   static std::vector<std::unique_ptr<Entity>> newEntities;
   static std::vector<size_t> entitiesToRemove;
 
   newEntities.clear();
   entitiesToRemove.clear();
 
   // Count current bubbles
   int bubble_count = 0;
   for (const auto &entity : entities) {
     if (dynamic_cast<Bubble *>(entity.get())) {
       bubble_count++;
     }
   }
 
   // Update all entities and collect changes
   for (size_t i = 0; i < entities.size(); ++i) {
     auto &entity = entities[i];
     entity->update();
 
     // Handle fish bubble spawning with configuration
     if (g_config.enable_bubbles && bubble_count < g_config.max_bubbles) {
       if (auto *fish = dynamic_cast<Fish *>(entity.get())) {
         if (fish->shouldSpawnBubble()) {
           // Use configured bubble rate
           if (rand() % g_config.fish_bubble_rate == 0) {
             newEntities.emplace_back(
                 std::make_unique<Bubble>(fish->getX(), fish->getY()));
             bubble_count++;
           }
         }
       }
     }
 
     if (entity->shouldBeRemoved()) {
       auto replacement = entity->createReplacement();
       if (replacement) {
         entity = std::move(replacement);
         entities_need_sorting = true;
       } else {
         entitiesToRemove.push_back(i);
       }
     }
   }
 
   // Remove entities in reverse order to maintain indices
   for (auto it = entitiesToRemove.rbegin(); it != entitiesToRemove.rend();
        ++it) {
     entities.erase(entities.begin() + *it);
     entities_need_sorting = true;
   }
 
   // Add new entities if we have them and haven't exceeded max
   if (!newEntities.empty() &&
       entities.size() < static_cast<size_t>(g_config.max_entities)) {
     entities.reserve(entities.size() + newEntities.size());
     for (auto &newEntity : newEntities) {
       entities.emplace_back(std::move(newEntity));
     }
     entities_need_sorting = true;
   }
 
   ensureEntitiesSorted();
 
   // Draw all entities
   for (const auto &entity : entities) {
     entity->draw();
   }
 
   // Draw debug information
   if (g_config.show_fps || g_config.show_entity_count) {
     drawDebugInfo();
   }
 
   renderToScreen();
 }
 
 void Aquarium::drawDebugInfo() {
   static double last_fps = 0.0;
   static int frame_counter = 0;
   static auto last_time = std::chrono::steady_clock::now();
 
   frame_counter++;
   auto current_time = std::chrono::steady_clock::now();
   auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                      current_time - last_time)
                      .count();
 
   if (elapsed >= 1000) {
     last_fps = (frame_counter * 1000.0) / elapsed;
     frame_counter = 0;
     last_time = current_time;
   }
 
   std::stringstream debug_info;
   if (g_config.show_fps) {
     debug_info << "FPS: " << std::fixed << std::setprecision(1) << last_fps;
   }
   if (g_config.show_entity_count) {
     if (g_config.show_fps)
       debug_info << " | ";
     debug_info << "Entities: " << entities.size();
   }
 
   std::string debug_str = debug_info.str();
   if (!debug_str.empty()) {
     std::string color_str(debug_str.length(), 'w'); // White color
     drawToFrame(0, width - static_cast<int>(debug_str.length()), debug_str,
                 color_str);
   }
 }
 
 void Aquarium::resize() {
   printf("%s%s%s", ANSI::CLEAR_SCREEN, ANSI::CURSOR_HOME, ANSI::BG_BLACK);
   fflush(stdout);
 
   getTerminalSize();
 
   currentFrame.assign(height, std::vector<Cell>(width));
   previousFrame.assign(height, std::vector<Cell>(width));
 
   entities.clear();
   entities_need_sorting = true;
 
   addWaterline();
   addCastle();
 
   // Use configured seaweed count or auto-calculate
   int seaweed_count = g_config.initial_seaweed_count;
   if (seaweed_count == -1) {
     seaweed_count = width / 15;
   }
   for (int i = 0; i < seaweed_count; i++) {
     addSeaweed();
   }
 
   // Use configured fish count or auto-calculate
   int fish_count = g_config.initial_fish_count;
   if (fish_count == -1) {
     fish_count = width * (height - 9) / 350;
   }
   for (int i = 0; i < fish_count; i++) {
     addFish();
   }
 }
 
 void Aquarium::addFish() { addEntityImpl<Fish>(); }
 void Aquarium::addBubble(float x, float y) { addEntityImpl<Bubble>(x, y); }
 void Aquarium::addSeaweed() { addEntityImpl<Seaweed>(); }
 void Aquarium::addWaterline() { addEntityImpl<Waterline>(); }
 void Aquarium::addCastle() { addEntityImpl<Castle>(); }
 void Aquarium::addShip() { addEntityImpl<Ship>(); }
 void Aquarium::addSeaMonster() { addEntityImpl<SeaMonster>(); }
 void Aquarium::addWhale() { addEntityImpl<Whale>(); }
 
 void Aquarium::ensureBigEntityExists() {
   // Check if any big entities exist on screen
   for (const auto &entity : entities) {
     if (dynamic_cast<Ship *>(entity.get()) ||
         dynamic_cast<SeaMonster *>(entity.get()) ||
         dynamic_cast<Whale *>(entity.get())) {
       return; // Big entity found, do nothing
     }
   }
 
   // No big entity found, spawn next in cycle
   int entity_type = big_entity_index % 3;
   if (entity_type == 0) {
     addEntityImpl<Ship>();
   } else if (entity_type == 1) {
     addEntityImpl<SeaMonster>();
   } else {
     addEntityImpl<Whale>();
   }
   ++big_entity_index;
 }
 
 void Aquarium::clearCurrentFrame() {
   static const Cell empty_cell{};
 
   for (auto &row : currentFrame) {
     row.assign(width, empty_cell);
   }
 }
 
 void Aquarium::drawToFrame(int y, int x, const std::string &line,
                            const std::string &colorLine) {
   const size_t len = std::min(line.size(), colorLine.size());
 
   for (size_t j = 0; j < len; ++j) {
     int cx = x + static_cast<int>(j);
     if (cx < 0 || cx >= width)
       continue;
 
     const char ch = line[j];
     const char colorChar = colorLine[j];
     const bool isBold = (colorChar >= 'A' && colorChar <= 'Z');
 
     currentFrame[y][cx] = {
         ch, static_cast<char>(isBold ? colorChar + 32 : colorChar), isBold};
   }
 }
 
 void Aquarium::initColorLookup() {
   for (int i = 0; i < 256; ++i)
     colorLookup[i] = ANSI::BLACK; // Default black
 
   colorLookup['r'] = ANSI::RED;
   colorLookup['g'] = ANSI::GREEN;
   colorLookup['y'] = ANSI::YELLOW;
   colorLookup['b'] = ANSI::BLUE;
   colorLookup['m'] = ANSI::MAGENTA;
   colorLookup['c'] = ANSI::CYAN;
   colorLookup['w'] = ANSI::WHITE;
   colorLookup['k'] = ANSI::BLACK;
 }
 
 void Aquarium::renderToScreen() {
   static std::string output;
   output.clear();
   output.reserve(height * width * 20);
 
   int cursor_y = -1, cursor_x = -1;
 
   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x) {
       const Cell &newCell = currentFrame[y][x];
       Cell &oldCell = previousFrame[y][x];
 
       if (newCell == oldCell)
         continue;
 
       oldCell = newCell;
 
       // Move cursor only when needed
       if (cursor_y != y || cursor_x != x) {
         output += ANSI::moveTo(y, x);
         cursor_y = y;
         cursor_x = x;
       }
 
       // Apply cell formatting and character
       output += ANSI::RESET_BLACK_BG;
 
       // Only apply bold if configured
       if (g_config.use_bold && newCell.bold) {
         output += ANSI::BOLD;
       }
 
       // Only apply colors if configured
       if (g_config.use_colors) {
         output += colorLookup[static_cast<unsigned char>(newCell.colorChar)];
       }
 
       output += newCell.ch;
       ++cursor_x;
     }
   }
 
   if (!output.empty()) {
     std::cout << output << std::flush;
   }
 }
 
 // Check for input (non-blocking)
 int Aquarium::checkInput() {
   char c;
   if (read(STDIN_FILENO, &c, 1) == 1) {
     return c;
   }
   return -1; // No input available
 }
 
 // Check if terminal was resized
 bool Aquarium::checkResize() {
   struct winsize ws;
   if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0) {
     if (ws.ws_row != height || ws.ws_col != width) {
       return true;
     }
   }
   return false;
 }
 
 Aquarium::~Aquarium() { cleanup_terminal(0); }