aufbauspiel/Input/inputHandler.c

#include "inputHandler.h"
#include "raylib.h"
#include "../sprite.h"
#include "../IsometricMap/isometricMap.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "../List/list.h"
#include "../IsometricMap/tile.h"
#include "../game.h"

void DrawRect(Vector2 rectStart, Vector2 *mousePosition){
    float width = GetMousePosition().x - rectStart.x;
    float height = GetMousePosition().y - rectStart.y;

    rectStart = GetRectangle(rectStart);

    DrawRectangleLines(rectStart.x, rectStart.y, abs(width), abs(height), GREEN);
}

Vector2 GetRectangle(Vector2 rectStart){
    float width = GetMousePosition().x - rectStart.x;
    float height = GetMousePosition().y - rectStart.y;

    if(width < 0 && height >= 0){
        width *= -1;
        rectStart.x -= width;
    }
    else if(height < 0 && width >= 0){
        height *= -1;
        rectStart.y -= height;
    }
    else if(height < 0 && width < 0){
        height *= -1;
        width *= -1;
        rectStart.x -= width;
        rectStart.y -= height;
    }
    return rectStart;
}

void mouseInput(Game *game){

    InputHandler *inputHandler = game->inputHandler;
    List *sprites = game->sprites;
    Camera2D *camera = game->camera;
    IsometricMap **layers = game->layers;
    Texture2D *texture = game->worker +4;

    inputHandler->cursorPos.x = GetMousePosition().x;
    inputHandler->cursorPos.y = GetMousePosition().y;


    // bissl Kamera Zoom
    float maxZoom = 5.0f;
    float minZoom = 0.2f;
    if(IsKeyPressed(KEY_I)){
        if(camera->zoom < maxZoom){
            camera->zoom += 0.2f;
        }
    }
    if(IsKeyPressed(KEY_K)){
        if(camera->zoom > minZoom){
            camera->zoom -= 0.2f;
        }
    }
    // resetting last selected Tile to grass texture
    if(inputHandler->selectedLayer != -1){
        IsometricMapChangeTextureIdOfTile(layers, (int) inputHandler->cursorWorldTile.x, (int) inputHandler->cursorWorldTile.y, inputHandler->selectedLayer, 0);
    }
    
    // hardcoded layer amount
    int n = 9;
    for(n = 9; n >= 0 ; n--){
        if(layers[n] != 0){
            float tileWidthHalf = layers[n]->tileTextures[0].width / 2;
            float tileHeightQuarter = layers[n]->tileTextures[0].height / 4;
            int mouseAdjustmentX = -tileWidthHalf;
            int mouseAdjustmentY = -tileHeightQuarter + (tileHeightQuarter * layers[n]->layer);

            // Updating inputHandler->cursorWorldPos Vector2D
            IsometricMapProject(layers[n], camera, 
            (inputHandler->cursorPos.x / camera->zoom) + mouseAdjustmentX, 
            (inputHandler->cursorPos.y / camera->zoom) + mouseAdjustmentY, 
            &inputHandler->cursorWorldPos);
           
/*N I C E*/     Tile *selectedTile = IsometricMapGetTileFromWorldCoordinates(layers, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y, n);
            
            if(selectedTile != 0){
                inputHandler->cursorWorldTile.x = selectedTile->x;
                inputHandler->cursorWorldTile.y = selectedTile->y;
                inputHandler->selectedLayer = n;
                // setting currently selected tile to tower
                IsometricMapChangeTextureIdOfTile(layers, inputHandler->cursorWorldTile.x, inputHandler->cursorWorldTile.y, n, 1);
                break;
            }
        }
    }


    if(IsMouseButtonPressed(MOUSE_BUTTON_LEFT)){
        if(inputHandler->pressed == 0){
            inputHandler->rectStart.x = GetMousePosition().x;
            inputHandler->rectStart.y = GetMousePosition().y;
            inputHandler->pressed = 1;

            // Cursorsprite is changed to "down"
            inputHandler->cursorSprite->texture = (inputHandler->cursorTextures) + 1;
        }
        
    }

    if(inputHandler->pressed){
        DrawRect(inputHandler->rectStart, &(inputHandler->cursorPos));
    }

    if(IsMouseButtonReleased(MOUSE_BUTTON_LEFT)){
        inputHandler->pressed = 0;
        // Cursorsprite is changed back to normal
        inputHandler->cursorSprite->texture = (inputHandler->cursorTextures);
        float width = GetMousePosition().x - inputHandler->rectStart.x;
        float height = GetMousePosition().y - inputHandler->rectStart.y;


        // Add Sprite
        if(abs(width) + abs(height) < 20){  
            int maxWidth = (game->layers[0]->width) * game->layers[0]->textureWidth;
            int maxHeight = (game->layers[0]->height) * game->layers[0]->textureHeight;          
            if(inputHandler->cursorWorldPos.x < 0){ printf("OutOfBoundsDestination Spawn\n");}
            else if(inputHandler->cursorWorldPos.y < 0){ printf("OutOfBoundsDestination Spawn\n");}
            else if(inputHandler->cursorWorldPos.x > maxWidth){ printf("OutOfBoundsDestination Spawn\n");}
            else if(inputHandler->cursorWorldPos.y > maxHeight){ printf("OutOfBoundsDestination Spawn\n");}
            else {
                ListInsertBack(sprites, SpriteCreate(game->textures, 1, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y));
                //ListInsertSorted(sprites, SpriteCreate(game->textures, 1, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y));
            }
        } else{
            // Berechnung, welche Sprites ausgewählt wurden
            Vector2 rect = GetRectangle(inputHandler->rectStart);
            width = abs(width);
            height = abs(height);

            float deltaX;
            float deltaY;
            Node *current = sprites->head;
            while (current != 0){
                Vector2 currPos = {current->data->x + current->data->texture->width, current->data->y + current->data->texture->height/2};
                IsometricMapUnproject(layers, camera, currPos.x, currPos.y, current->data->z, &currPos);

                deltaX = currPos.x - camera->target.x - (rect.x + camera->target.x);
                deltaY = currPos.y - camera->target.y - (rect.y + camera->target.y);

                if(deltaX > 0 && deltaX < width && deltaY > 0 && deltaY < height){
                    current->data->selected = 1;
                }
                else{
                    current->data->selected = 0;
                }

                current = current->next;
            }
        }
    }

    if(IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)){
        Node *current = sprites->head;

        while (current != 0){
            if(current->data->selected){
                current->data->hasDestination = 1;
                float destX = inputHandler->cursorWorldPos.x;
                float destY = inputHandler->cursorWorldPos.y;
                int maxWidth = (game->layers[0]->width-1) * game->layers[0]->textureWidth;
                int maxHeight = (game->layers[0]->height-1) * game->layers[0]->textureHeight;
                if(destX < 0){ printf("OutOfBoundsDestination\n"); goto skip; }
                if(destY < 0){ printf("OutOfBoundsDestination\n"); goto skip; }
                if(destX > maxWidth){ printf("OutOfBoundsDestination\n"); goto skip; }
                if(destY > maxHeight){ printf("OutOfBoundsDestination\n"); goto skip; }

                current->data->destX = destX;
                current->data->destY = destY;
            }

            skip: current = current->next;
        }
    }
}

void keyboardInput(InputHandler *inputHandler, Camera2D *camera){
    float camSpeed = 1000.0f;
    if(IsKeyDown(KEY_W)){
        (*camera).target.y -= camSpeed * GetFrameTime();
    }
    if(IsKeyDown(KEY_S)){
        (*camera).target.y += camSpeed * GetFrameTime();
    }
    if(IsKeyDown(KEY_D)){
        (*camera).target.x += camSpeed * GetFrameTime();
    }
    if(IsKeyDown(KEY_A)){
        (*camera).target.x -= camSpeed * GetFrameTime();
    }
}