basic1/games/monopoly/MonopolyBoardRenderer.h

#pragma once
#include "../../display/low_level_render.h"
#include "monopoly_board.h"
#include "player.h"
#include <cstring>

class MonopolyBoardRenderer {
public:
    static void draw_tile(LowLevelRenderer* renderer, int x, int y, int w, int h, int index, bool is_corner, Player* players, int players_count, int orientation = 0, int currentPlayerPos = -1) {
        if (index < 0 || index >= BOARD_SIZE) return;
        
        bool isInverted = (index == currentPlayerPos);
        if (isInverted) {
            renderer->draw_filled_rectangle(x, y, w, h, true, 1);
            renderer->set_text_color(false); // Black text on white background
        } else {
            renderer->draw_rectangle(x, y, w, h, true, 1);
        }
        
        const BoardTile& tile = MONOPOLY_BOARD[index];
        int content_x = x, content_y = y, content_w = w, content_h = h;

        if (!is_corner && tile.type == TILE_PROPERTY) {
            int bar_size = 10;
            int bx = x, by = y, bw = w, bh = h;
            
            if (orientation == 0) { // Bottom row (Bar on top)
                bh = bar_size;
                content_y += bar_size; content_h -= bar_size;
            } else if (orientation == 1) { // Left column (Bar on right)
                bx = x + w - bar_size; bw = bar_size;
                content_w -= bar_size;
            } else if (orientation == 2) { // Top row (Bar on bottom)
                by = y + h - bar_size; bh = bar_size;
                content_h -= bar_size;
            } else if (orientation == 3) { // Right column (Bar on left)
                bw = bar_size;
                content_x += bar_size; content_w -= bar_size;
            }

            if (isInverted) {
                // In inverted mode, the bar should be black (transparent/inverted)
                renderer->draw_filled_rectangle(bx, by, bw, bh, false, 0); // Clear the bar area back to black
                renderer->set_text_color(true); // Groups on the bar are usually white text on black bar in this mode
            } else {
                renderer->draw_filled_rectangle(bx, by, bw, bh, true, 1);
                renderer->set_text_color(false); // Black text on white bar
            }
            
            // Group number
            char gbuf[2] = { (char)('0' + tile.group[0]), '\0' };
            renderer->draw_string_scaled(bx + (bw - 6) / 2, by + (bh - 8) / 2, gbuf, 1);
            
            if (isInverted) renderer->set_text_color(false); // Back to black text for the rest of the tile
            else renderer->set_text_color(true);
        }

        char short_name[5] = {0};
        const char* full_name = tile.name;
        
        if (is_corner) {
            strncpy(short_name, full_name, 4);
        } else {
            short_name[0] = full_name[0];
            const char* space = strchr(full_name, ' ');
            if (space && space[1] != '\0') short_name[1] = space[1];
        }
        
        for (int i = 0; short_name[i]; i++) if(short_name[i] >= 'a' && short_name[i] <= 'z') short_name[i] -= 32;

        renderer->draw_string_scaled(content_x + (content_w - (int)strlen(short_name) * 6) / 2, content_y + (content_h - 8) / 2, short_name, 1);

        // Draw player markers
        int p_count = 0;
        for (int i = 0; i < players_count; ++i) {
            if (players[i].position == index) {
                char mark[2] = { (players[i].token ? players[i].token[0] : 'P'), '\0' };
                renderer->draw_string_scaled(content_x + 2 + (p_count * 8), content_y + 2, mark, 1);
                p_count++;
            }
        }

        if (isInverted) {
            renderer->set_text_color(true); // Reset for next tiles
        }
    }

    static void draw_board_perimeter(LowLevelRenderer* renderer, int width, int height, Player* players, int players_count, int currentPlayerPos = -1) {
        int cw = width / 7;   // Corner width
        int ch = height / 7;  // Corner height
        int rw = (width - 2 * cw) / 9;  // Regular tile width
        int rh = (height - 2 * ch) / 9; // Regular tile height

        // --- Bottom Row: 0 to 10 (Right to Left) ---
        draw_tile(renderer, width - cw, height - ch, cw, ch, 0, true, players, players_count, 0, currentPlayerPos); // GO
        for (int i = 1; i < 10; ++i) {
            draw_tile(renderer, width - cw - i * rw, height - ch, rw, ch, i, false, players, players_count, 0, currentPlayerPos);
        }
        draw_tile(renderer, 0, height - ch, cw, ch, 10, true, players, players_count, 1, currentPlayerPos); // JAIL

        // --- Left Column: 11 to 19 (Bottom to Top) ---
        for (int i = 11; i < 20; ++i) {
            draw_tile(renderer, 0, height - ch - (i - 10) * rh, cw, rh, i, false, players, players_count, 1, currentPlayerPos);
        }

        // --- Top Row: 20 to 30 (Left to Right) ---
        draw_tile(renderer, 0, 0, cw, ch, 20, true, players, players_count, 2, currentPlayerPos); // FREE PARKING
        for (int i = 21; i < 30; ++i) {
            draw_tile(renderer, cw + (i - 21) * rw, 0, rw, ch, i, false, players, players_count, 2, currentPlayerPos);
        }
        draw_tile(renderer, width - cw, 0, cw, ch, 30, true, players, players_count, 3, currentPlayerPos); // GO TO JAIL

        // --- Right Column: 31 to 39 (Top to Bottom) ---
        for (int i = 31; i < 40; ++i) {
            draw_tile(renderer, width - cw, ch + (i - 31) * rh, cw, rh, i, false, players, players_count, 3, currentPlayerPos);
        }
    }
};