Iterator loops forever ?

[Angeljruiz]

//
//  main.cpp
//  Snake
//
//  Created by Angel on 9/25/12.
//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
//

#include <allegro5/allegro.h>
#include <allegro5/allegro_primitives.h>
#include <cstdlib>
#include <time.h>
#include <vector>

#include <iostream>

using namespace std;

enum dir{ LEFT, UP, RIGHT, DOWN };

struct Tile {
    public:
    bool On;
    bool Special;
    int x,y;
};
class Snake {
public:
    vector<Tile> vTiles;
    int pX,pY;
    int eX,eY;
};

bool isWall(int,int);
void SetupTiles(Tile Tiles[][15]);
void GenTile(Tile Tiles[][15]);
void Move(Snake &aSnake,Tile Tiles[][15],dir);
void Gameover(Snake &aSnake, Tile Tiles[][15]);

int main(int argc, char **argv)
{
    srand((unsigned int)time(NULL));

    ALLEGRO_DISPLAY *display = NULL;
    ALLEGRO_EVENT_QUEUE *event_queue = NULL;
    ALLEGRO_TIMER *timer = NULL;
    
    bool Exit = false;
    bool Redraw = true;
    
    vector<Tile>::iterator it;

     

    Tile Tiles[20][15] = { false, false, 0, 0 };
    
    for (int x = 0; x < 20; ++x)
    {
        for (int y = 0; y < 15; ++y) 
        {
            Tiles[x][y].x = x;
            Tiles[x][y].y = y;
        }
    }
    
    SetupTiles(Tiles);
    GenTile(Tiles);
    
    Snake aSnake;
        
    aSnake.vTiles.push_back(Tiles[2][4]);
    aSnake.vTiles.push_back(Tiles[2][5]);
    aSnake.vTiles.push_back(Tiles[2][6]);


    
    
    al_init();
    al_install_keyboard();
    al_init_primitives_addon();
    
    timer = al_create_timer(1.0 / 120);
    if (!timer)
        exit(-1);
    display = al_create_display(640, 480);
    event_queue = al_create_event_queue();
    
    al_register_event_source(event_queue, al_get_display_event_source(display));
    al_register_event_source(event_queue, al_get_keyboard_event_source());
    al_register_event_source(event_queue, al_get_timer_event_source(timer));
    
    
    al_start_timer(timer);
    

    while (!Exit)
    {
        ALLEGRO_EVENT ev;
        al_wait_for_event(event_queue, &ev);
        
        if (ev.type == ALLEGRO_EVENT_KEY_UP)
        {
            switch (ev.keyboard.keycode)
            {
                case ALLEGRO_KEY_ESCAPE:
                    Exit = true;
                    break;
                    
                case ALLEGRO_KEY_A:
                    GenTile(Tiles);
                    Move(aSnake, Tiles, RIGHT);
                    Redraw = true;
                    break;
                    
                case ALLEGRO_KEY_LEFT:
                    Move(aSnake, Tiles, LEFT);
                    //Gameover(aSnake, Tiles);
                    Redraw = true;
                    break;
                    
                case ALLEGRO_KEY_UP:
                    Move(aSnake, Tiles, UP);
                    Redraw = true;
                    break;
                    
                case ALLEGRO_KEY_RIGHT:

                    Move(aSnake, Tiles, RIGHT);
                    Redraw = true;
                    break;
                    
                case ALLEGRO_KEY_DOWN:
                    Move(aSnake, Tiles, DOWN);
                    Redraw = true;
                    break;
                    
            }
        }
        
        if (ev.type == ALLEGRO_EVENT_TIMER)
        {
            //Redraw = true;
        }
        //exit(-5);
        if (al_event_queue_is_empty(event_queue) && Redraw)
        {
            vector<Tile>::iterator it;
            al_clear_to_color(al_map_rgb(245, 245, 245));
            for (it = aSnake.vTiles.begin(); it != aSnake.vTiles.end(); ++it) {
                al_draw_filled_rectangle(it->x*32, it->y*32, it->x*32+32, it->y*32+32, al_map_rgb(0, 0, 0));
            }
            for (int x = 0; x < 20; ++x)
            {
                for (int y = 0; y < 15; ++y)
                {
                    if (Tiles[x][y].On)
                        al_draw_filled_rectangle(x*32, y*32, x*32+32, y*32+32, al_map_rgb(0, 0, 0));
                    if (Tiles[x][y].Special)
                        al_draw_filled_rectangle(x*32, y*32, x*32+32, y*32+32, al_map_rgb(255, 0, 0));
                    if (x)
                        al_draw_line(x*32, 0, x*32, 480, al_map_rgb(220, 220, 220), 3);
                    if (y)
                        al_draw_line(0, y*32, 640, y*32, al_map_rgb(220, 220, 220), 3);
                }
            }
            al_flip_display();
            Redraw = false;
        }
        
        
    }
    
    if (display) al_destroy_display(display);
    if (timer) al_destroy_timer(timer);
    if (event_queue) al_destroy_event_queue(event_queue);
    
    
    
    return 0;
}

bool isWall(int x, int y)
{
    if (x == 0 || y == 0)
        return true;
    if (x == 19)
        return true;
    if (y == 14)
        return true;
    return false;
}
void SetupTiles(Tile Tiles[][15])
{
    for (int x = 0; x < 20; ++x)
    {
        Tiles[x][0].On = true;
    }
    for (int y = 0; y < 15; ++y)
    {
        Tiles[19][y].On = true;
    }
    for (int x = 19; x >= 0; --x)
    {
        Tiles[x][14].On = true;
    }
    for (int y = 14; y >= 0; --y)
    {
        Tiles[0][y].On = true;
    }
}
void GenTile(Tile Tiles[][15])
{
    int tX = rand() % 18 + 1;
    int tY = rand() % 13 + 1;
    if (Tiles[tX][tY].On || Tiles[tX][tY].Special)
        GenTile(Tiles);
    Tiles[tX][tY].Special = true;
}
void Move(Snake &aSnake, Tile Tiles[][15], dir Direction)
{
    vector<Tile>::iterator it;
    vector<Tile>::iterator it2;
    int tX, tY;
    for (it = aSnake.vTiles.begin(); it != aSnake.vTiles.end(); ++it) {
        if (it == aSnake.vTiles.begin())
        {
            aSnake.pX = it->x;
            aSnake.pY = it->y;
            switch (Direction)
            {
                case LEFT:
                    if (isWall(it->x-1, it->y)) {
                        Gameover(aSnake, Tiles);
                        return;
                    }
                    if (Tiles[it->x-1][it->y].Special) {
                        Tiles[it->x-1][it->y].Special = false;
                        GenTile(Tiles);
                        aSnake.vTiles.push_back(Tiles[aSnake.eX][aSnake.eY]);
                    }
                    it->x -= 1;
                    break;
                    
                case UP:
                    if (isWall(it->x, it->y-1)) {
                        Gameover(aSnake, Tiles);
                        return;
                    }
                    if (Tiles[it->x][it->y-1].Special) {
                        Tiles[it->x][it->y-1].Special = false;
                        GenTile(Tiles);
                        aSnake.vTiles.push_back(Tiles[aSnake.eX][aSnake.eY]);
                    }
                    it->y -= 1;
                    break;
                    
                case RIGHT:
                    if (isWall(it->x+1, it->y)) {
                        Gameover(aSnake, Tiles);
                        return;
                    }
                    if (Tiles[it->x+1][it->y].Special) {
                        Tiles[it->x+1][it->y].Special = false;
                        GenTile(Tiles);
                        aSnake.vTiles.push_back(Tiles[aSnake.eX][aSnake.eY]);
                    }
                    it->x += 1;
                    break;
                    
                case DOWN:
                    if (isWall(it->x, it->y+1)) {
                        Gameover(aSnake, Tiles);
                        return;
                    }
                    if (Tiles[it->x][it->y+1].Special) {
                        Tiles[it->x][it->y+1].Special = false;
                        GenTile(Tiles);
                        aSnake.vTiles.push_back(Tiles[aSnake.eX][aSnake.eY]);
                    }
                    it->y += 1;
                    break;
            }
        } else {
            tX = it->x;
            tY = it->y;
            aSnake.eX = tX;
            aSnake.eY = tY;
            it->x = aSnake.pX;
            it->y = aSnake.pY;
            aSnake.pX = tX;
            aSnake.pY = tY;
        }  
    }
}
void Gameover(Snake &aSnake, Tile Tiles[][15])
{
 //omitted
    
}

In the move function it seems it loop forever once you collect two points (This is a snake type game ). So after the snake collides twice with a special tile it crashes. Sorry im not very good at explaining.
PS - It says i made this file 3 days ago but it only has a hour or so of work , Just felt like throwing it out there :p

[pogrady]

Don't you need to dereference the interator when acting or calling one of the methods that it points to?

[Angeljruiz]

I am i think. -> deferences

[Aramil of Elixia]

no it doesn't. u use -> when u have a pointer to an object to access its data members. i dont think there is actually a derefernce operator

[Angeljruiz]

Ohh, so what do i do then ?

[Aramil of Elixia]

ummm.... never actually had to use them so i think u just NULL it

[Angeljruiz]

Wait what line are you talking about exactly ? X)

[cire]

no it doesn't. u use -> when u have a pointer to an object to access its data members. i dont think there is actually a derefernce operator

In fact there is a dereference operator, however, as with pointers, -> does actually act to dereference the pointer.

ummm.... never actually had to use them so i think u just NULL it

If you don't have any idea what you're talking about, it's probably best to keep the mouth closed or asking questions instead of making statements.

[Angeljruiz]

bump.... if someone could just like look over my move function itd be great >.<

[cire]

I don't see anything obvious, but I suspect it's one of the calls to GenTiles since that function could potentially recurse forever.

I did refactor the move function just so it was a little easier to see what was going on.

void Move(Snake &aSnake, Tile Tiles[][15], dir Direction)
{
    vector<Tile>::iterator it = aSnake.vTiles.begin() ;

    // set previous head position
    aSnake.pX = it->x ;
    aSnake.pY = it->y ;

    int newX=it->x, newY=it->y ;

    switch (Direction)
    {
    case LEFT: 
        newX -= 1 ;
        break;
    case UP:
        newY -= 1 ;
        break ;
    case RIGHT:
        newX += 1 ;
        break ;
    case DOWN:
        newY += 1 ;
        break ;
    }

    if ( isWall(newX, newY) )
    {
        Gameover(aSnake, Tiles) ;
        return ;
    }

    if ( Tiles[newX][newY].Special )
    {
        Tiles[newX][newY].Special = false ;
        GenTile(Tiles) ;
        aSnake.vTiles.push_back(Tiles[aSnake.eX][aSnake.eY]) ;
    }

    it->x = newX ;
    it->y = newY ; 

    // update the rest of the snake

    for (++it; it != aSnake.vTiles.end(); ++it) 
    {
        int tX = it->x;
        int tY = it->y;

        aSnake.eX = tX;
        aSnake.eY = tY;

        it->x = aSnake.pX;
        it->y = aSnake.pY;

        aSnake.pX = tX;
        aSnake.pY = tY;
    }
}

[Angeljruiz]

Thanks, that does look alot better :p But it would only recurse forever if all tiles are already special

    for (++it; it != aSnake.vTiles.end(); ++it)  //Iterator goes bad here
    {
        int tX = it->x;
        int tY = it->y;

        aSnake.eX = tX;
        aSnake.eY = tY;

        it->x = aSnake.pX;
        it->y = aSnake.pY;

        aSnake.pX = tX;
        aSnake.pY = tY;
    }

EDIT: Solved :p just replaced for (++it; it != aSnake.vTiles.end(); ++it) with for (it = aSnake.vTiles.begin()+1; it != aSnake.vTiles.end(); ++it)

[cire]

Ah yes. The push_back must've invalidated the iterator. You'll probably also want to make sure

    it->x = newX ;
    it->y = newY ; 

happens before the push_back.