Merge branch 'IsometricMath' into 'main'

Several improvements with IsometricMath and its structure

See merge request JonathanHager/aufbauspiel!3

Input/inputHandler.c

@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <math.h>
 #include "../List/list.h"
+#include "../IsometricMap/tile.h"
 
 //TODO: Macht es Sinn ein einzelnes "Game" struct zu haben, das alle möglichen Pointer hat zu allen arrays, camera, textures etc?
 // Man hat einen Übergabeparameter mit dem man dann alles verändern kann, man muss nicht alles was man verändern will einzeln übergeben
@@ -53,17 +54,34 @@ Vector2 GetRectangle(Vector2 rectStart){
     return rectStart;
 }
 
-void mouseInput(InputHandler *inputHandler, List *sprites, Texture2D *texture, Camera2D *camera, IsometricMap *map){
+void mouseInput(InputHandler *inputHandler, List *sprites, Texture2D *texture, Camera2D *camera, IsometricMap **layers){
 
     inputHandler->cursorPos.x = GetMousePosition().x;
     inputHandler->cursorPos.y = GetMousePosition().y;
 
     // resetting last selected Tile to grass texture
-    IsometricMapChangeTextureIdOfTile(map, (int) inputHandler->selectedTile.x, (int) inputHandler->selectedTile.y, 0);
+    int n = 9;
-    // updating selected tile
+    if(inputHandler->selectedLayer != -1){
-    IsometricMapProject(map, camera, inputHandler->cursorPos.x, inputHandler->cursorPos.y, &inputHandler->selectedTile);
+        IsometricMapChangeTextureIdOfTile(layers[inputHandler->selectedLayer], (int) inputHandler->cursorWorldPos.x, (int) inputHandler->cursorWorldPos.y, 0);
-    // setting currently selected tile to tower 
+    }
-    IsometricMapChangeTextureIdOfTile(map, (int) inputHandler->selectedTile.x, (int) inputHandler->selectedTile.y, 1);
+    // TODO: n=2 no good style, but Segmentation fault when > layerAmount
+    for(n = 10; n >= 0 ; n--){
+        if(layers[n] != 0){
+
+            IsometricMapProject(layers[n], camera, inputHandler->cursorPos.x, inputHandler->cursorPos.y, &inputHandler->cursorWorldPos);
+           
+            Tile *selectedTile = IsometricMapGetTileFromWorldCoordinates(layers[n], inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y);
+            
+            if(selectedTile != 0){
+                inputHandler->cursorWorldPos.x = selectedTile->x;
+                inputHandler->cursorWorldPos.y = selectedTile->y;
+                // setting currently selected tile to tower
+                inputHandler->selectedLayer = n;
+                IsometricMapChangeTextureIdOfTile(layers[n], (int) inputHandler->cursorWorldPos.x, (int) inputHandler->cursorWorldPos.y, 1);
+                break;
+            }
+        }
+    }
 
 
     if(IsMouseButtonPressed(MOUSE_BUTTON_LEFT)){

Input/inputHandler.h

@@ -9,11 +9,11 @@ typedef struct InputHandler{
     int pressed;
     Vector2 rectStart;
     Vector2 cursorPos;
-    Vector2 selectedTile;
+    Vector2 cursorWorldPos;
     int selectedLayer;
 } InputHandler;
 
-void mouseInput(InputHandler *inputHandler, List *sprites, Texture2D *texture, Camera2D *camera, IsometricMap *map);
+void mouseInput(InputHandler *inputHandler, List *sprites, Texture2D *texture, Camera2D *camera, IsometricMap **layers);
 
 void keyboardInput(InputHandler *inputHandler, Camera2D *camera);
 

IsometricMap/isometricMap.c

@@ -5,37 +5,37 @@
 #include "raymath.h"
 #include "raylib.h"
 
-IsometricMap * IsometricMapInit(int x, int y, int layer){
+IsometricMap * IsometricMapInit(int layer){
     IsometricMap* map = (IsometricMap *) malloc(sizeof(IsometricMap));
     map->tileTextures[0] = LoadTexture("assets/grass.png");
     map->tileTextures[1] = LoadTexture("assets/tower.png");
 
     map->originX = 0;
     map->originY = -layer * map->tileTextures[0].width / 4;
-    map->width = x * map->tileTextures[0].width;
+    map->width = 100 * map->tileTextures[0].width;
-    map->height = y * map->tileTextures[0].height;
+    map->height = 100 * map->tileTextures[0].height;
+    map->widthBounds = 100;
+    map->heightBounds = 100;
+    map->layer = layer;
 
-   Tile*** tiles = (Tile***)malloc(x*sizeof(Tile*));
+   Tile*** tiles = (Tile***)malloc(map->widthBounds*sizeof(Tile*));
    int n = 0;
-   for(n=0; n<x; n++){
+   for(n=0; n < map->widthBounds; n++){
-        tiles[n] = (Tile**)malloc(y*sizeof(Tile*));
+        tiles[n] = (Tile**)malloc(map->heightBounds*sizeof(Tile*));
    }
 
-    map->sizeX = x;
-    map->sizeY = y;
-
     int i = 0;
     int j = 0;
-    
+    for(i=0; i < map->widthBounds; i++){
-    for(i=0; i < x; i++){
+        for(j=0; j < map->heightBounds; j++){
-        for(j=0; j < y; j++){
             Tile *tmp = (Tile *) malloc(sizeof(Tile));
-            tmp->textureId = 0;
+            tmp->textureId = -1;
             tmp->x = i;
             tmp->y = j;
             tiles[i][j] = tmp;
         }
     }
+
     map->tiles = tiles;
 
     return map;
@@ -59,13 +59,14 @@ Tile * IsometricMapGetTileFromArrayPosition(IsometricMap *map, int x, int y){
     return map->tiles[x][y];
 }
 
-void IsometricMapProject(IsometricMap *isometricMap, Camera2D *camera, int x, int y, Vector2 *tmp){
+void IsometricMapProject(IsometricMap *isometricMap, Camera2D *camera, float x, float y, Vector2 *tmp){
-
-    int mouseAdjustmentX = -8;
-    int mouseAdjustmentY = -4;
 
     float tileWidthHalf = isometricMap->tileTextures[0].width / 2;
-    float tileHeightHalf = isometricMap->tileTextures[0].height / 4;
+    float tileHeightQuarter = isometricMap->tileTextures[0].height / 4;
+
+    int mouseAdjustmentX = -tileWidthHalf;
+    int mouseAdjustmentY = -tileHeightQuarter + (tileHeightQuarter * isometricMap->layer);
+
 
     x += camera->target.x + mouseAdjustmentX;
     y += camera->target.y + mouseAdjustmentY;
@@ -74,38 +75,46 @@ void IsometricMapProject(IsometricMap *isometricMap, Camera2D *camera, int x, in
     float yPos = (float) y;
 
 
-    int isoX = 0.5 * ( xPos / tileWidthHalf + yPos / tileHeightHalf);
+    float isoX = 0.5 * ( xPos / tileWidthHalf + yPos / tileHeightQuarter);
-    int isoY = 0.5 * ( -xPos / tileWidthHalf + yPos / tileHeightHalf);
+    float isoY = 0.5 * ( -xPos / tileWidthHalf + yPos / tileHeightQuarter);
 
+    tmp->x = isoX * isometricMap->tileTextures[0].width;
+    tmp->y = isoY * isometricMap->tileTextures[0].height;
+}
 
-    //Vector2 tmp = {isoX * tileWidthHalf * 2, isoY * tileHeightHalf * 2};
+Tile * IsometricMapGetTileFromWorldCoordinates(IsometricMap *isometricMap, float x, float y){
-    //Vector2* tmp = (Vector2 *) malloc(sizeof(Vector2));
-    tmp->x = isoX;
-    tmp->y = isoY;
 
-    //return tmp;
+    x = (int)(x / isometricMap->tileTextures->width);
-}
+    y = (int)(y / isometricMap->tileTextures->height);
 
+    Tile *ptr = (Tile *) malloc(sizeof(Tile *));
+    ptr->x = 0;
+    ptr->y = 0;
 
-void IsometricMapAddTile(IsometricMap *isometricMap, int x, int y, int textureId){
+    if( x < isometricMap->widthBounds && y < isometricMap->heightBounds &&
+        x >= 0 && y >= 0 ){
+            if(isometricMap->tiles[(int)x][(int)y]->textureId != -1){
+                ptr->x = isometricMap->tiles[(int)x][(int)y]->x;
+                ptr->y = isometricMap->tiles[(int)x][(int)y]->y;
+                return ptr;
+            }
+    }
+    ptr = 0;
+    return ptr;
+}
 
-    //if(x < isometricMap->sizeX && y < isometricMap->sizeY){
-        
-        Tile *tile = (Tile *) malloc(sizeof(Tile));
-        tile->textureId = textureId;
-        tile->x = x;
-        tile->y = y;
-        
-        //Tile tile = {textureId, x, y};
-        isometricMap->tiles[x][y] = tile;
 
-    //}
 
+void IsometricMapAddTile(IsometricMap *isometricMap, int x, int y, int textureId){
+    isometricMap->tiles[x][y]->textureId = textureId;
+    isometricMap->tiles[x][y]->x = x;
+    isometricMap->tiles[x][y]->y = y;
+        
 }
 
 void IsometricMapChangeTextureIdOfTile(IsometricMap *map, int x, int y, int id){
-    if( x < map->sizeX && y < map->sizeY &&
+    if( x < map->widthBounds && y < map->heightBounds &&
-        x > map->originX && y > map->originY ){
+        x >= 0 && y >= 0 ){
         (map->tiles[x][y])->textureId = id;
    }
 }

IsometricMap/isometricMap.h

@@ -6,12 +6,13 @@
 typedef struct IsometricMap{
     Texture2D tileTextures[10];
     Tile ***tiles;
-    int sizeX;
-    int sizeY;
     int originX;
     int originY;
     int width;
     int height;
+    int widthBounds;
+    int heightBounds;
+    int layer;
 } IsometricMap;
 
 // TODO:
@@ -20,11 +21,11 @@ Tile * IsometricMapGetTileFromWorldCoordinates(IsometricMap *isometricMap, float
 Vector2 IsometricMapUnproject(IsometricMap *isometricMap, Camera2D *camera, int x, int y);
 
 // Working
-IsometricMap * IsometricMapInit(int x, int y, int layer);
+IsometricMap * IsometricMapInit(int layer);
 Vector2 * IsometricMapCalcOffsetForTileAt(int x, int y, int textureSize);
 Tile * IsometricMapGetTileFromArrayPosition(IsometricMap *isometricMap, int x, int y);
 // Screen Coordinates -> World Coordinates 
-void IsometricMapProject(IsometricMap *isometricMap, Camera2D *camera, int x, int y, Vector2 *tmp);
+void IsometricMapProject(IsometricMap *isometricMap, Camera2D *camera, float x, float y, Vector2 *tmp);
 
 void IsometricMapAddTile(IsometricMap *isometricMap, int x, int y, int textureId);
 void IsometricMapChangeTextureIdOfTile(IsometricMap *map, int x, int y, int id);

IsometricMap/isometricRenderer.c

@@ -35,21 +35,28 @@ void IsometricRendererDrawMap(IsometricRenderer *renderer, int height){
     }
 }
 
-void IsometricRendererRenderIsometricMap(IsometricMap *map, InputHandler *input){
+void IsometricRendererRenderIsometricMap(IsometricMap **map, InputHandler *input){
 
+    int n = 0;
     int i = 0;
     int j = 0;
-    for(i=0; i < map->sizeX; i++){
+    for(n = 0; n < 10; n++){
-        for(j=0; j < map->sizeY; j++){
+        if(map[n] == 0){
-            Vector2 *offset = IsometricMapCalcOffsetForTileAt(i,j, map->tileTextures[0].width);
+            break;
-            
+        }
-            float x = map->originX + offset->x;
+        for(i=0; i < map[n]->widthBounds; i++){
-            float y = map->originY + offset->y;
+            for(j=0; j < map[n]->heightBounds; j++){
-
+                if(map[n]->tiles[i][j]->textureId != -1){
-            int textureId = map->tiles[i][j]->textureId;
+                    Vector2 *offset = IsometricMapCalcOffsetForTileAt(i,j, map[n]->tileTextures[0].width);
-            
+                    
-            DrawTexture(map->tileTextures[textureId], x, y, WHITE);
+                    float x = map[n]->originX + offset->x;
+                    float y = map[n]->originY + offset->y;
+
+                    int textureId = map[n]->tiles[i][j]->textureId;
+                    
+                    DrawTexture(map[n]->tileTextures[textureId], x, y, WHITE);
+                }
+            }
         }
     }
-
 }

IsometricMap/isometricRenderer.h

@@ -10,6 +10,6 @@ typedef struct IsometricRenderer{
 
 void IsometricRendererDrawMap(IsometricRenderer *renderer, int height);
 
-void IsometricRendererRenderIsometricMap(IsometricMap *map, InputHandler *input);
+void IsometricRendererRenderIsometricMap(IsometricMap **map, InputHandler *input);
 
 #endif

README.md

@@ -14,6 +14,4 @@ Fantasy Welt oder Realistisch?
 ## TODO
 
 + Sprites in LinkedList speichern
-+ LinkedList erweitern
++ LinkedList erweitern
-+ IsometricMap Array erstellen für die verschiedenen Layer
-+ Auswählen von Tiles auf höheren Layern

main.c

@@ -27,9 +27,9 @@ int main(){
     inputHandler.rectStart.y = 0;
     inputHandler.cursorPos.x = 0;
     inputHandler.cursorPos.y = 0;
-    inputHandler.selectedTile.x = 0;
+    inputHandler.cursorWorldPos.x = 0;
-    inputHandler.selectedTile.y = 0;
+    inputHandler.cursorWorldPos.y = 0;
-    inputHandler.selectedLayer = 0;
+    inputHandler.selectedLayer = -1;
 
     Camera2D camera = { 0 };
     camera.target = (Vector2){0, 0};
@@ -39,13 +39,55 @@ int main(){
     // TODO -> Isometric Map Array for multiple Layers
     // -> Make only most upper layer selectable
     // take selected Tile, if that tile has one above select a tile in the upper layer
-    IsometricMap *map = IsometricMapInit(50, 80, 0);
+    //IsometricMap *map = IsometricMapInit(50, 80, 0);
-    IsometricMap *Layer1 = IsometricMapInit(20, 20, 1); 
+    //IsometricMap *Layer1 = IsometricMapInit(20, 20, 1); 
-    IsometricMap *Layer2 = IsometricMapInit(15, 15, 2); 
+    //IsometricMap *Layer2 = IsometricMapInit(15, 15, 2); 
-    IsometricMap *Layer3 = IsometricMapInit(10, 10, 3); 
+    //IsometricMap *Layer3 = IsometricMapInit(10, 10, 3); 
-    IsometricMap *Layer4 = IsometricMapInit(4, 4, 4); 
+    //IsometricMap *Layer4 = IsometricMapInit(4, 4, 4); 
+
+    IsometricMap **layers = (IsometricMap **) malloc(10*sizeof(IsometricMap *));
+ 
+    int n = 0;
+    int i = 0;
+    int j = 0;
+
+    for(n = 0; n < 10; n++){
+        layers[n] = IsometricMapInit(n);
+    }
+
+    for(n = 0; n <= 10; n++){
+        for(i = 0; i < 100; i++){
+            for(j = 0; j < 100; j++){
+                switch(n){
+                    case 0:
+                        IsometricMapAddTile(layers[n], i, j, 0);
+                        break;
+                    case 1:
+                        if(i > 35 && i < 50 && j > 45 && j < 60){
+                            IsometricMapAddTile(layers[n], i, j, 0);
+                        }
+                        break;
+                    case 2:
+                        if(i > 40 && i < 44 && j > 50 && j < 54){
+                            IsometricMapAddTile(layers[n], i, j, 1);
+                        }
+                        break;
+                }
 
-    IsometricMapAddTile(Layer4, 2, 2, 1);
+            }   
+        }
+    }
+
+    for(n = 0; n <= 10; n++){
+        for(i = 0; i < 20-n*2; i++){
+            for(j = 0; j < 20-n*2; j++){
+                IsometricMapAddTile(layers[n], i, j, 0);
+                if(n == 9){
+                    IsometricMapAddTile(layers[n], i, j, 1);
+                }
+            }
+        }
+    }
 
     SetTargetFPS(60);
     while(!WindowShouldClose()){
@@ -56,11 +98,13 @@ int main(){
 
         BeginMode2D(camera);
 
-        IsometricRendererRenderIsometricMap(map, &inputHandler);
+        //IsometricRendererRenderIsometricMap(map, &inputHandler);
-        IsometricRendererRenderIsometricMap(Layer1, &inputHandler);
+        //IsometricRendererRenderIsometricMap(Layer1, &inputHandler);
-        IsometricRendererRenderIsometricMap(Layer2, &inputHandler);
+        //IsometricRendererRenderIsometricMap(Layer2, &inputHandler);
-        IsometricRendererRenderIsometricMap(Layer3, &inputHandler);
+        //IsometricRendererRenderIsometricMap(Layer3, &inputHandler);
-        IsometricRendererRenderIsometricMap(Layer4, &inputHandler);
+        //IsometricRendererRenderIsometricMap(Layer4, &inputHandler);
+
+        IsometricRendererRenderIsometricMap(layers, &inputHandler);
         
         ListDrawAllSprites(sprites);
         
@@ -72,7 +116,7 @@ int main(){
         DrawSprite(&cursorSprite);
 
         // User Input Handling
-        mouseInput(&inputHandler, sprites, &texture, &camera, map);
+        mouseInput(&inputHandler, sprites, &texture, &camera, layers);
         keyboardInput(&inputHandler, &camera);
 
         // Sprites move towards their destination