[C/C++ && SDL] Parsing arrays met pointers

[Tijmen007]

De titel kan nergens op slaan, maar dat maak ik van de fout die de compiler mij geeft.

Wat ik probeer te doen
De SDL structs naar een collision functie parsen. Deze zal 0 terug sturen als de speler zich niet in één van de objecten in de scene bevindt. Dit gaat zo:

C++: gamemechanics

#include <SDL/SDL.h>

int collision(struct SDL_Rect rectangle1,struct SDL_Rect rectangle2)
{
    if (rectangle1.x + rectangle1.h < rectangle2.x || rectangle1.x > rectangle2.x + rectangle2.h || rectangle1.y > rectangle2.y + rectangle2.w || rectangle1.y + rectangle1.w < rectangle2.y)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

Veder is er nog de main.cpp, zoals hieronder te vinden. Header file heeft niet zoveel zin om te posten. Het probleem is dus dat wanneer ik collision() gebruik hij me een foutmelding geeft. "ERROR: '<anonymous>' has incomplete type" en "ERROR: forward declaration of 'struct rectangle1'", etc.

Code::Blocks 1.1
GNU GCC Compiler 4.7
SDL 1.2.9 miniGW

C++: main

#include <SDL/SDL.h>
#include "gamemechanics.h"

int main(int argc, char** argv)
{
    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_Surface *screen;
    screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
    //screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE|SDL_FULLSCREEN);
    bool running = true;

    bool movement[4] = {0,0,0,0};

    int movementSpeed = 3;

    const int FPS = 60;
    Uint32 start;

    SDL_Rect rect1;
    rect1.x = 40;
    rect1.y = 40;
    rect1.w = 40;
    rect1.h = 40;

    SDL_Rect rect2;
    rect2.x = 0;
    rect2.y = 240;
    rect2.w = 200;
    rect2.h = 40;

    SDL_Rect rect3;
    rect3.x = 160;
    rect3.y = 0;
    rect3.w = 40;
    rect3.h = 160;

    Uint32 color1 = SDL_MapRGB(screen -> format, 0,0,0);
    Uint32 color2 = SDL_MapRGB(screen -> format, 255,255,255);

    while(running)
    {
        start = SDL_GetTicks();

        //input interface
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_QUIT:
                    running = false;
                    break;
                case SDL_KEYDOWN:
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_UP:
                            movement[0] = 1;
                            break;
                        case SDLK_DOWN:
                            movement[1] = 1;
                            break;
                        case SDLK_LEFT:
                            movement[2] = 1;
                            break;
                        case SDLK_RIGHT:
                            movement[3] = 1;
                            break;
                        case SDLK_r:
                            rect1.x = 0;
                            rect1.y = 0;
                            break;
                        case SDLK_ESCAPE:
                            running = false;
                            break;
                    }
                    break;
                case SDL_KEYUP:
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_UP:
                            movement[0] = 0;
                            break;
                        case SDLK_DOWN:
                            movement[1] = 0;
                            break;
                        case SDLK_LEFT:
                            movement[2] = 0;
                            break;
                        case SDLK_RIGHT:
                            movement[3] = 0;
                            break;
                    }
                    break;
            }
        }

        collisions(rect1Array,ObjectsPresent,numberOfObjectsPresent);

        //movement logic

            if (movement[0])
            {
                rect1.y -= movementSpeed
                if (collision(rect1,rect2))
                {
                    rect1.y += movementSpeed + 1;
                }
            }
            if (movement[1])
            {
                rect1.y += movementSpeed
                if (collision(rect1,rect2))
                {
                    rect1.y -= movementSpeed + 1;
                }
            }
            if (movement[2])
            {
                rect1.x -= movementSpeed
                if (collision(rect1,rect2))
                {
                    rect1.x += movementSpeed + 1;
                }
            }
            if (movement[3])
            {
                rect1.x += movementSpeed
                if (collision(rect1,rect2))
                {
                    rect1.x -= movementSpeed + 1;
                }
            }

        //render section
        SDL_FillRect(screen, &screen -> clip_rect, color1);
        SDL_FillRect(screen, &rect1, color2);
        SDL_FillRect(screen, &rect2, color2);
        SDL_FillRect(screen, &rect3, color2);

        SDL_Flip(screen);

        if (1000/FPS > SDL_GetTicks() - start)
        {
            SDL_Delay(1000/FPS - (SDL_GetTicks() - start));
        }
    }
    SDL_Quit();
    return 0;
}

[ Voor 83% gewijzigd door Tijmen007 op 27-04-2013 12:56 ]

[Raynman]

collision verwacht twee arrays, in collisions geef je een array en een int mee. De error zegt dat die int niet zo maar naar int* geconverteerd kan worden, wat hier ongeveer gelijk is aan int[]; zoeken op iets als 'c pointers arrays' moet echt wel wat nuttige info opleveren.

En gebruik a.u.b. code-tags. Dan kun je die twee functies ook gewoon in je post zetten en hoeven we niet drie pagina's naast elkaar te leggen.

Iets anders (zonder echt goed naar main.cpp te kijken): waarom zet je die SDL_Rects om naar int[4] met een comment "array = { 0 x, 1 y, 2 w, 3 h}" bij je functies? Als je gewoon die structs gebruikt wordt bijv. die if in collision een stuk leesbaarder.

[Tijmen007]

Raynman schreef op zaterdag 27 april 2013 @ 12:07:
En gebruik a.u.b. code-tags. Dan kun je die twee functies ook gewoon in je post zetten en hoeven we niet drie pagina's naast elkaar te leggen.

Iets anders (zonder echt goed naar main.cpp te kijken): waarom zet je die SDL_Rects om naar int\[4] met een comment "array = { 0 x, 1 y, 2 w, 3 h}" bij je functies? Als je gewoon die structs gebruikt wordt bijv. die if in collision een stuk leesbaarder.

Die code-tags deden het weer eens niet in mijn voorbeeld, dus ik gebruikte maar even pastebin om de boel helder te behouden.

Ik zet ze om omdat ik rect1 niet zomaar kan doorgeven zover ik weet. Ik zal het nu nog eens proberen, maar ik meen me te herinneren dat het een hoop ellende gaf. Zal zo even mijn bevindingen rapporteren Bedankt alvast!

EDIT1:

C++: collision

int collision(struct SDL_Rect rectangle1,struct SDL_Rect rectangle2)
{
    if (rectangle1.x + rectangle1.h < rectangle2.x || rectangle1.x > rectangle2.x + rectangle2.h || rectangle1.y > rectangle2.y + rectangle2.w || rectangle1.y + rectangle1.w < rectangle2.y)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

Dit werkt dus zonder compiler errors, maar collisions werken dan in zijn geheel niet meer (het is altijd true (1)).

[ Voor 78% gewijzigd door Tijmen007 op 27-04-2013 12:52 ]

[Tijmen007]

Het werkt allemaal weer, dit was meer een kwestie van slordigheid veder. Bedankt Raynman voor het duwtje in de juiste richting. De werkende code voor geinteresseerde:

C++: gamemechanics

#include <SDL/SDL.h>

int collision(struct SDL_Rect rectangle1,struct SDL_Rect rectangle2)
{
    if (rectangle1.x + rectangle1.w < rectangle2.x || rectangle1.x > rectangle2.x + rectangle2.w || rectangle1.y > rectangle2.y + rectangle2.h || rectangle1.y + rectangle1.h < rectangle2.y)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

[farlane]

Overweeg om de SDL_Rect dmv pointers door te geven om het kopieren naar de stack te voorkomen. ( een en ander is afhankelijk van hoe groot die struct is )

[Verwijderd]

Of gebruikt const T&.

Bij de huidige code zal de compiler elke functieaanroep een kopie van de struct maken, al zal dat in sommige situaties weggeoptimaliseerd kunnen worden.

[epic007]

farlane schreef op zaterdag 27 april 2013 @ 15:09:
Overweeg om de SDL_Rect dmv pointers door te geven om het kopieren naar de stack te voorkomen. ( een en ander is afhankelijk van hoe groot die struct is )

Zoals bijvoorbeeld hier: http://wiki.libsdl.org/moin.fcg/SDL_HasIntersection