std::bad_alloc

#include <stdio.h>
#include <iostream>
#include <cv.h>
#include <highgui.h>
 
#include <vector>
#include <math.h>
 
using namespace std;
 
 
 
/* ---------------------
----- Òèïû -------------
--------------------- */
 
class Vector2
{
    public:
        int x, y;
        
        Vector2(int x1, int y1)
        {
            x = x1;
            y = y1;
        }
        
        const Vector2 operator+(const Vector2& v) const {
            return Vector2(x + v.x, y + v.y);
        }
};
 
 
class Field
{
    public:
        
        int xMax, yMax;
        vector< vector<bool> > field;
        
        
        
        Field(int xSize, int ySize)
        {
            xMax = xSize;
            yMax = ySize;
            
            
            field = vector< vector<bool> > (xMax);
            
            for(int x = 0; x < xMax; x++)
            {
                field[x] = vector<bool> (yMax);
                
                for(int y = 0; y < yMax; y++)
                {
                    field[x][y] = false;
                }
            }
        }
        
        void swap(Field f)
        {
            field.swap(f.field);
        }
        
        bool isAlive(Vector2 coord)
        {
            Vector2 rCoord = at(coord);
            return field[rCoord.x][rCoord.y];
        }
        
        void reverse(Vector2 coord)
        {
            Vector2 rCoord = at(coord);
            field[rCoord.x][rCoord.y] = !field[rCoord.x][rCoord.y];
        }
        
        void revitalize(Vector2 coord)
        {
            Vector2 rCoord = at(coord);
            field[rCoord.x][rCoord.y] = true;
        }
        
        void kill(Vector2 coord)
        {
            Vector2 rCoord = at(coord);
            field[rCoord.x][rCoord.y] = false;
        }
        
        
    protected:
        
        Vector2 at(Vector2 coord)
        {
            int xCoord = coord.x % xMax;
            int yCoord = coord.y % yMax;
            
            
            if(xCoord < 0)
            {
                xCoord += xMax;
            }
            
            if(yCoord < 0)
            {
                yCoord += yMax;
            }
            
            return Vector2(xCoord, yCoord);
        }
};
 
/* ---------------------
--------------------- */
 
 
 
/* ---------------------
----- Ïàðàìåòðû --------
--------------------- */
 
IplImage* IMAGE = cvLoadImage("background.png", 1);
IplImage* SRC = cvCloneImage(IMAGE);
 
bool isActive = false;
 
int X_SIZE;
int Y_SIZE;
 
int e;
 
 
int B_MIN;
int B_MAX;
int S_MIN;
int S_MAX;
 
const int numOfNeighbors = 6;
const Vector2 neighbors[numOfNeighbors] = 
{
    Vector2(+1, -1),
    Vector2(+1, +0),
    Vector2(+0, +1),
    Vector2(-1, +1),
    Vector2(-1, +0),
    Vector2(+0, -1)
};
 
 
Field CUR_FIELD(0, 0);
Field NEW_FIELD(0, 0);
 
/* ---------------------
--------------------- */
 
 
 
/* ---------------------
----- Ôóíêöèîíàë èãðû --
--------------------- */
 
bool isAlive(Vector2 coord)
{
    int sum = 0;
    
    for(int i = 0; i < numOfNeighbors; i++)
    {
        Vector2 neighborsCoord = coord + neighbors[i];
        
        if( CUR_FIELD.isAlive(neighborsCoord) )
        {
            sum++;
        }
    }
    
    if(CUR_FIELD.isAlive(coord))
    {
        return !((sum < S_MIN) || (sum > S_MAX));
    }
    else
    {
        return !((sum < B_MIN) || (sum > B_MAX));
    }
}
 
 
void update(void)
{
    for(int x = 0; x < X_SIZE; x++)
    {
        for(int y = 0; y < Y_SIZE; y++)
        {
            Vector2 coord = Vector2(x, y);
            
            if( isAlive(coord) )
            {
                NEW_FIELD.revitalize(coord);
            }
            else
            {
                NEW_FIELD.kill(coord);
            }
        }
    }
    
    CUR_FIELD.swap(Field(NEW_FIELD));
    NEW_FIELD.swap(Field(X_SIZE, Y_SIZE));
}
 
/* ---------------------
--------------------- */
 
 
 
/* ---------------------
----- Ãðàôèêà ----------
--------------------- */
 
Vector2 indexToCoord(Vector2 index, int e)
{
    double newX = e * (0.5 + index.x + index.y / 2.0);
    double newY = e * (0.5 + index.y * 0.8660254037844386);
    
    return Vector2(ceil(newX), ceil(newY));
}
 
Vector2 coordToIndex(Vector2 coord, int e)
{
    double xCoord = (double) coord.x;
    double yCoord = (double) coord.y;
    
    int y = floor( 2 * yCoord / (1.7320508075688772 * e) );
    int x = floor( (xCoord / e) - (y / 2.0) );
    
    return Vector2(x, y);
}
 
void drowHexagon(IplImage* img, bool fill, Vector2 coord, int e)
{
    CvPoint *pts = new CvPoint[sizeof(CvPoint) * 6];
    
    int x = coord.x;
    int y = coord.y;
    
    pts[0] = cvPoint(x + e / 2, y + e / 3.4641016151377544);
    pts[1] = cvPoint(x,         y + e / 1.7320508075688772);
    pts[2] = cvPoint(x - e / 2, y + e / 3.4641016151377544);
    pts[3] = cvPoint(x - e / 2, y - e / 3.4641016151377544);
    pts[4] = cvPoint(x,         y - e / 1.7320508075688772);
    pts[5] = cvPoint(x + e / 2, y - e / 3.4641016151377544);
    
    if(fill)
    {
        cvFillConvexPoly(img, pts, 6, CV_RGB(0, 0, 0));
    }
    else
    {
        int PolyVertexNumber[1] = {6};
        cvFillConvexPoly(img, pts, 6, CV_RGB(255, 255, 255));
        cvPolyLine(img, &pts, PolyVertexNumber, 1, 1, cvScalar(0, 0, 0), 1, CV_AA, 0);
    }
}
 
 
void draw(char* windowName, Field GAME_FIELD)
{
    for(int x = 0; x < X_SIZE; x++)
    {
        for(int y = 0; y < Y_SIZE; y++)
        {
            Vector2 index = Vector2(x, y);
            if(index.x >= X_SIZE - index.y / 2)
            {
                index.x -= X_SIZE;
            }
            
            Vector2 coord = indexToCoord(index, e);
            
            drowHexagon(IMAGE, GAME_FIELD.isAlive(index), coord, e);
        }
    }
    
    cvCopyImage(IMAGE, SRC);
    cvShowImage(windowName, SRC);
}
 
void mouseCallback( int event, int x, int y, int flags, void* param )
{
    char* windowName = (char*) param;
    
    switch(event){
        case CV_EVENT_LBUTTONDOWN:
            CUR_FIELD.reverse( coordToIndex(Vector2(x, y), e) );
            draw(windowName, CUR_FIELD);
            break;
        
        case CV_EVENT_RBUTTONDOWN:
            isActive = false;
            
            for(int x = 0; x < X_SIZE; x++)
            {
                for(int y = 0; y < Y_SIZE; y++)
                {
                    Vector2 index = Vector2(x, y);
                    CUR_FIELD.kill(index);
                }
            }
            
            draw(windowName, CUR_FIELD);
            break;
    }
}
 
/* ---------------------
--------------------- */
 
 
 
/* ---------------------
----- Èíèöèàëèçàöèÿ ----
--------------------- */
 
int main(void)
{
    int delay;
    
    
    cout << "b1.b2 s1.s2: ";
    scanf("%d.%d %d.%d", &B_MIN, &B_MAX, &S_MIN, &S_MAX);
    
    cout << "Delay (ms): ";
    scanf("%d", &delay);
    
    cout << "Size (X Y): ";
    scanf("%d %d", &X_SIZE, &Y_SIZE);
    
    cout << "e (px): ";
    scanf("%d", &e);
    
    
    
    CUR_FIELD = Field(X_SIZE, Y_SIZE);
    NEW_FIELD = Field(X_SIZE, Y_SIZE);
    
    
    char WINDOW_NAME[] = "Hexagonal life";
    
    cvNamedWindow(WINDOW_NAME, CV_WINDOW_AUTOSIZE);
    cvSetMouseCallback(WINDOW_NAME, mouseCallback, (void*) WINDOW_NAME);
    
    draw(WINDOW_NAME, CUR_FIELD);
    
    while(true)
    {
        if(isActive)
        {
            update();
            draw(WINDOW_NAME, CUR_FIELD);
        }
        
        
        char c = cvWaitKey(delay);
        
        if (c == 27)
        {
            break;
        }
        else if(c == 32)
        {
            isActive = !isActive;
        }
    }
    
    
    cvReleaseImage(&IMAGE);
    cvReleaseImage(&SRC);
    cvDestroyWindow(WINDOW_NAME);
    
    return 0;
}
 
/* ---------------------
--------------------- */