Algorithmus zur Kachelgröße

Question

Ich mache ein Kachelspiel in C++.Wenn das Spiel jetzt geladen wird, platzieren sich alle Spielsteine ​​auf der Grundlage von:

Kachelgröße -> es sind Quadrate, das sind also Breite und Höhe

Tile_count_x

Tile_count_y

Ich habe die folgenden Variablen:

desktop_width

desktop_height

game_window_width

game_window_height

Tile_count_x

Tile_count_y

Basierend auf diesen Werten suche ich nach einem Algorithmus, der angesichts der Desktop- und Tile_Count-Einschränkungen eine geeignete Fenstergröße festlegt.Dann möchte ich, dass meine Kacheln einen Versatz haben, der x % um das Fenster herum begrenzt, was im Grunde auch die Kachelgröße bestimmt:

Beispiel:Wenn ich 10 * 3 Kacheln habe, dann:

______________________________
Window Title              _[]X
------------------------------
|                            |
|    [][][][][][][][][][]    | 
|    [][][][][][][][][][]    |
|    [][][][][][][][][][]    |
|                            |
------------------------------

Ich bin mir einfach nicht sicher, welche Formel dafür erforderlich ist.

EDIT (aus Kommentaren):

• Tilesize-Änderungen, Tilecountx und y sind statisch
• Ich möchte, dass das Spielfenster so groß ist, wie es bei der Desktop-Auflösung möglich ist, aber ich möchte auch, dass das Seitenverhältnis die Tilecoutx- und Tilecounty-Werte berücksichtigt

Ich habe ein Beispiel dafür gefunden, was ich meine: Öffnen Sie Minesweeper in Windows

Answer 1

So habe ich es gelöst...

        //WINDOW SIZE SETUP

        //choose the smaller TILE_SIZE
        if (DESKTOP_WIDTH / TILE_COUNT_X > DESKTOP_HEIGHT / TILE_COUNT_Y)
        {
            TILE_SIZE = DESKTOP_HEIGHT / TILE_COUNT_Y;
        }
        else
        {   
            TILE_SIZE = DESKTOP_WIDTH / TILE_COUNT_X;
        }
        //Set screen size and consider a 5 tile border
        SCREEN_WIDTH = TILE_SIZE * (TILE_COUNT_X + 5);
        SCREEN_HEIGHT = TILE_SIZE * (TILE_COUNT_Y + 5);

        //resize window until it satisfies resolution constraints
        while( SCREEN_WIDTH > (DESKTOP_WIDTH - (DESKTOP_WIDTH * 0.07)))
        {
            TILE_SIZE --;
        SCREEN_WIDTH = TILE_SIZE * (TILE_COUNT_X + 5);
        SCREEN_HEIGHT = TILE_SIZE * (TILE_COUNT_Y + 5);
        }

        while( SCREEN_HEIGHT > (DESKTOP_HEIGHT - (DESKTOP_HEIGHT * 0.15)))
        {
            TILE_SIZE -- ;
        SCREEN_WIDTH = TILE_SIZE * (TILE_COUNT_X + 5);
        SCREEN_HEIGHT = TILE_SIZE * (TILE_COUNT_Y + 5);
        }
for(int i = 0; i < 8; ++i)     //Ensure resolution is multiple of 8
{
    if (SCREEN_WIDTH % 8 != 0) //remainder means not multiple of 8
    {
        SCREEN_WIDTH += 1;
    }

    if (SCREEN_HEIGHT % 8 != 0)
    {
        SCREEN_HEIGHT += 1;
    }
}
        X_OFFSET = (SCREEN_WIDTH - (TILE_SIZE * TILE_COUNT_X)) / 2;
        Y_OFFSET = (SCREEN_HEIGHT - (TILE_SIZE * TILE_COUNT_Y)) / 2;

Answer 2

Ich bin kein C++-Programmierer, aber Sie sollten etwas davon haben:

// Amount of padding to leave around tiles (of window size)
int percentage = 10;

tile_ratio = tile_count_x / tile_count_y;
desktop_ratio = desktop_width / desktop_height;

// Determine the maximum window width and height
// according to tile and desktop aspect ratios
if(tile_ratio >= desktop_ratio) {
    window_width = desktop_width;
    window_height = window_width * (1 / tile_ratio);
} else {
    window_height = desktop_height;
    window_width = window_height * tile_ratio;
}

// Determine maximum width and height for tiles,
// taking account x% of padding on both sides, hence the * 2
tile_width = window_width * ((100 - (percentage * 2)) / 100);
tile_height = window_height * ((100 - (percentage * 2)) / 100);

// As the tiles must be square, determine the smaller side as the size
tile_size = tile_width < tile_height ? tile_width : tile_height;

// To maintain the x% padding, we must calculate the window size again as we just changed the tilesize
factor = (100 / (100 - (percentage * 2)));
window_width = tile_size * tile_count_x * factor;
window_height = tile_size * tile_count_y * factor;

Jetzt haben Sie die maximale Fensterbreite und -höhe, sodass:

1. Das Fenster hat das gleiche Seitenverhältnis wie die Kacheln
2. Das Fenster ist nicht größer als der Desktop
3. Das Fenster hat x % Polsterung an allen Seiten der Kacheln

Beachten Sie, dass ich diesen Code überhaupt nicht getestet habe, aber er sollen arbeiten.Wenn Sie Fehler finden, versuchen Sie zu verstehen, was ich versucht habe, und beheben Sie sie entsprechend.

Answer 3

Einfache lineare Algebra:

game_window_width = (tile_count_x * TILE_WIDTH) + 2*(game_window_width * X / 100)

Wir haben 2 Variablen (TILE_WIDTH Und X) und nur 1 Gleichung, also ähm, Sie haben kein Glück.

Sie müssen entweder angeben TILE_WIDTH oder X (der Abstand).Nehmen wir an, Sie geben an X, dann können Sie die Gleichung lösen:

TILE_WIDTH = (game_window_width - (2*(game_window_width * X / 100))) / 
             tile_count_x

Wenn wir die Höhe berücksichtigen und denselben Rand benötigen, haben wir zwei Gleichungen und drei Unbekannte.Immer noch SOL.

Answer 4

Wenn Sie mit Win32 arbeiten, können Sie beispielsweise Folgendes verwenden, um die Größe des Clientbereichs Ihres Fensters zunächst festzulegen.

initial_width = (tile_count_x * tile_size) + (border_width * 2);
initial_height = (tile_count_y * tile_size) + (border_width * 2);

Wenn das Fenster Größenänderungsereignisse empfängt, würden Sie einfach jede Kachel strecken (d. h.Vergrößern oder verkleinern Sie jede Kachel) um die Anzahl der Pixel, um die das Fenster erweitert oder verkleinert wurde (vorausgesetzt, die Achsen sind gesperrt, d. h. Sie können die Größe nicht einzeln ändern).

Mit anderen Worten würde die Tile_size variieren:

tile_size += window_resize_amount;

Dieser Code stammt aus dem Speicher, kann aber eine Idee geben.

DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU | WS_MINIMIZEBOX | WS_CAPTION;
DWORD dwExStyle = 0;

int border_width = tile_size; // make border 1 tile

RECT r, w;
SetRect(&r, 0, 0, (tile_count_x * tile_size) + (border_width * 2), (tile_count_y * tile_size) + (border_width * 2));
AdjustWindowRectEx(&r, dwStyle, FALSE, dwExStyle);
SystemParametersInfo(SPI_GETWORKAREA, 0, &w, 0);
int width = r.right - r.left;
int height = r.bottom - r.top;
int x = ((w.right - w.left) / 2) - (width / 2);
int y = ((w.bottom - w.top) / 2) - (height / 2);

hWnd = CreateWindowEx(dwExStyle, szClassName, szAppName, dwStyle, x, y, width, height, NULL, NULL, hInstance, 0);