Algorithme de dimensionnement des tuiles

Question

Je fais un jeu de tuiles en C++. En ce moment, lorsque le chargement du jeu toutes les tuiles se placent en fonction:

tilesize -> ils sont carrés si cela est la largeur et la hauteur

tile_count_x

tile_count_y

Je les variables suivantes:

desktop_width

desktop_height

game_window_width

game_window_height

tile_count_x

tile_count_y

Sur la base de ces valeurs, je suis à la recherche d'un algorithme qui définira une taille de fenêtre appropriée compte tenu des contraintes de bureau et tile_count. Ensuite, à l'intérieur, je veux que mes carreaux pour avoir un décalage qui frontière x% autour de la fenêtre qui sera essentiellement décider de la tilesize aussi:

Exemple: Si j'ai 10 * 3 tuiles puis:

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

Je ne suis pas sûr que la formule requise pour le faire.

EDIT (des commentaires):

• change Tilesize, tilecountx et y sont statiques
• Je veux que le gamewindow soit aussi grande qu'elle peut donner la résolution de bureau, mais je veux aussi son aspect rapport de respecter le tilecoutx et tilecounty

J'ai trouvé un exemple de ce que je veux dire, ouvrir démineur dans Windows

Answer 1

Voici comment je l'ai résolu ...

 //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

simple algèbre linéaire:

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

Nous avons 2 variables (TILE_WIDTH et X) et seulement 1 équation, donc euh, vous êtes hors de la chance. Vous devrez spécifier TILE_WIDTH ou X (la marge). Disons que vous spécifiez X, vous pouvez résoudre l'équation:

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

si l'on prend en compte la hauteur, et nécessitent la même frontière, nous avons 2 équations et 3 inconnues. Toujours SOL.

Answer 3

Je ne suis pas un programmeur C++, mais vous devriez obtenir quelque chose de ceci:

// 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; 

Maintenant, vous avez la largeur de la fenêtre et la hauteur maximum de sorte que:

1. La fenêtre est dans la même format que les carreaux
2. La fenêtre n'est pas plus grande que le bureau
3. La fenêtre a x% de rembourrage autour de tous les côtés des carreaux

Notez que je n'ai pas testé ce code du tout, mais devrait fonctionner. Si vous trouvez des erreurs, essayez de comprendre ce que j'ai essayé de faire et de corriger en conséquence.

Answer 4

Si vous travaillez avec Win32, vous pouvez utiliser quelque chose comme ce qui suit pour initialement dimensionner la zone client de votre fenêtre.

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

Lorsque les recieves de redimensionnement de la fenêtre des événements vous simplement StretchBlt chaque tuile (c.-à agrandir ou rétrécir chaque tuile) par le nombre de pixels que la fenêtre a été élargie ou réduite par (En supposant que l'axe sont verrouillés, que est vous ne pouvez pas redimensionner chacun indépendamment).

En d'autres termes, le tile_size varierait:

tile_size += window_resize_amount; 

Ce code est de la mémoire, mais il peut donner une idée.

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);