Растёт скорость таймера

            while(tt!=NULL) {
                float a1 = (t->f->x)-(tt->f->x);
                float a2 = (t->f->y)-(tt->f->y);
                float a3 = (tt->f->x)-(t->f->x);
                float a4 = (tt->f->y)-(t->f->y);
                if((((a1<=102) && (a1>=100)) || ((a3<=102) && (a3>=100))) && (((a2>=0) && (a2<=100)) || ((a4>=0) && (a4<=100)))) {
                    t->f->dX*=-1;
                    tt->f->dX*=-1;
                    Collision(t->f,tt->f);
                }
                if((((a2<=100) && (a2>=98)) || ((a4<=100) && (a4>=98))) && (((a1>=0) && (a1<=100)) || ((a3>=0) && (a3<=100)))) {
                    t->f->dY*=-1;
                    tt->f->dY*=-1;
                    Collision(t->f,tt->f);
                }
                tt = tt->next;
            }

#include <windows.h>
 
#include <glut.h>
//#include <GL\GLAux.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
//#pragma comment (lib, "Glaux.lib")
#pragma comment (lib, "Winmm.lib")
#include <list>
#include <vector>
#include <memory>
#include <iostream>
 
int w = 1000;
int h = 600;
int speed = 1;
int limit = 5;
int counter = 0;
int life = 20000;
 
#define DELTA_MOVE 0.5*10
 
class Fish {
public:
    bool predator;
    float x;
    float y;
    float age;
    float type;
    float r;
    float dX;
    float dY;
    Fish (const Fish& t) {
        predator = t.predator;
        x = t.x;
        y = t.y;
        age = 0;
        type = t.type;
        r = 100.0;
        dX = DELTA_MOVE;
        dY = DELTA_MOVE;
    }
    Fish(bool a, float b, float c, float d) {
        predator = a;
        x = b;
        y = c;
        age = 0;
        type = d;
        r = 100.0;
        rand();
        dX = (((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE;
        dY = (((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE;
    }
 
    void Draw() {
        glTranslatef(x,y,0);
        if(type==0)
            glColor3f(1,1,1);
        else if(type==1)
            glColor3f(0,1,1);
        else
            glColor3f(1,0,0);
        glBegin(GL_QUADS);
            glTexCoord2f(0,1); glVertex2f(0,0); 
            glTexCoord2f(1,1); glVertex2f(100,0);
            glTexCoord2f(1,0); glVertex2f(100,100);
            glTexCoord2f(0,0); glVertex2f(0,100);
        glEnd();
    }
    void Trace()
    {
        age++;
        x+=dX;
        y+=dY;
        
        if(y>=h-100) dY*=-1;
        if(y<=-h) dY*=-1;
        
        if(x>=w-100) dX*=-1;
        if(x<=-w) dX*=-1;
    }
};
 
typedef std::shared_ptr<Fish> FishPtr;
std::list<FishPtr> fishes;
 
void SKeyboard(int key, int x, int y)
{
    int delta = 5;
    switch(key)
    {
        case GLUT_KEY_LEFT:
            speed+=delta;
            break;
        case GLUT_KEY_RIGHT:
            speed-=delta;
            break;
    }
 
    if (speed < 0)
        speed = 0;
}
int fps = 0;
DWORD lastTime = 0;
void Draw()
{
    fps++;
    DWORD time = ::timeGetTime();
    if (time - lastTime > 1000)
    {
        std::cout << "fps: " << fps << std::endl;
        lastTime = time;
        fps = 0;
    }
    glClear(GL_COLOR_BUFFER_BIT);
    for(std::list<FishPtr>::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
    {
        Fish& fish = *(*iter);
        glPushMatrix();
        fish.Draw();
        glPopMatrix();
    }
    glutSwapBuffers();
    //glFlush();
}
 
void Collision(const Fish& a, const Fish& b) {
    if(a.predator==true && b.predator==false) {
        //ab.del(b);
    }
    if(b.predator==true && a.predator==false) {
        //ab.del(a);
    }
    if(a.predator==false && b.predator==false) {
        //ab.add(new Fish(false,(0),(0),0));
        if(counter<=limit) {
            FishPtr ttt(new Fish(false,a.x - b.x,a.y - b.y,0));
            if ((int)fishes.size()<limit)
                fishes.push_back(ttt);
        }
    }
    if(a.predator==true && b.predator==true) {
        //ab.add(new Fish(true,(0),(0),2));
        if(counter<limit) {
            //Fish ttt(false,a.x - b.x,a.y - b.y,0);
            FishPtr ttt(new Fish(false,rand()%1-400,rand()%1-200,0));
            if ((int)fishes.size()<limit)
                fishes.push_back(ttt);
        }
    }
}
 
void Timer(int = 0)
{
        for(std::list<FishPtr>::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = *(*iter);
            for(std::list<FishPtr>::iterator iterSecond = fishes.begin(); iterSecond != fishes.end(); ++iterSecond)
            {
                if (iter == iterSecond)
                    continue;
                Fish& second = *(*iterSecond);
                float a1 = (first.x)-(second.x);
                float a2 = (first.y)-(second.y);
                float a3 = (second.x)-(first.x);
                float a4 = (second.y)-(first.y);
                if((((a1<=102) && (a1>=100)) || ((a3<=102) && (a3>=100))) && (((a2>=0) && (a2<=100)) || ((a4>=0) && (a4<=100)))) {
                    first.dX*=-1;
                    second.dX*=-1;
                    Collision(first,second);
                }
                if((((a2<=100) && (a2>=98)) || ((a4<=100) && (a4>=98))) && (((a1>=0) && (a1<=100)) || ((a3>=0) && (a3<=100)))) {
                    first.dY*=-1;
                    second.dY*=-1;
                    Collision(first,second);
                }
            }
        }
        std::vector<std::list<FishPtr>::iterator> remove;
        for(std::list<FishPtr>::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = *(*iter);
            first.Trace();
            if(first.age >= life) remove.push_back(iter);
        }
 
        for(std::vector<std::list<FishPtr>::iterator>::iterator iter = remove.begin(); iter != remove.end(); ++iter)
        {
            fishes.erase(*iter);
        }
 
        srand(time(NULL));
        glutTimerFunc(speed, Timer, 0);
        glutPostRedisplay();
}
 
int _tmain(int argc, _TCHAR* argvOrig[])
{
    fishes.push_back(FishPtr(new Fish(true,-200,100,2)));
    fishes.push_back(FishPtr(new Fish(false,-50,0,0)));
    fishes.push_back(FishPtr(new Fish(false,150,350,1)));
    glutInit(&arg, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB );
    glutInitWindowSize(w,h);
    glMatrixMode(GL_PROJECTION);
    glutInitWindowPosition(100,200);
    glutCreateWindow("Aquarium v4.0");
 
    glClearColor(0.0,0.0,0.0,1.0);
    glLoadIdentity();
    gluOrtho2D(-w,w,-h,h);
 
    glutDisplayFunc(Draw);
    glutTimerFunc(speed, Timer, 0);
    glutSpecialFunc(SKeyboard);
 
    glutMainLoop();
}

void main(int argc, char **argv)
{
    glutInit(&argc, argv);

#include <windows.h>
 
#include <glut.h>
//#include <GL\GLAux.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
//#pragma comment (lib, "Glaux.lib")
#pragma comment (lib, "Winmm.lib")
#include <list>
#include <vector>
#include <memory>
#include <iostream>
 
int w = 1000;
int h = 600;
int speed = 1;
int limit = 5;
int counter = 0;
int life = 20000;
 
#define DELTA_MOVE 0.5*10
 
class Fish {
public:
    bool predator;
    float x;
    float y;
    float age;
    float type;
    float r;
    float dX;
    float dY;
    Fish (const Fish& t) {
        predator = t.predator;
        x = t.x;
        y = t.y;
        age = 0;
        type = t.type;
        r = 100.0;
        dX = DELTA_MOVE;
        dY = DELTA_MOVE;
    }
    Fish(bool a, float b, float c, float d) {
        predator = a;
        x = b;
        y = c;
        age = 0;
        type = d;
        r = 100.0;
        rand();
        dX = (((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE;
        dY = (((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE;
    }
 
    void Draw() {
        glTranslatef(x,y,0);
        if(type==0)
            glColor3f(1,1,1);
        else if(type==1)
            glColor3f(0,1,1);
        else
            glColor3f(1,0,0);
        glBegin(GL_QUADS);
            glTexCoord2f(0,1); glVertex2f(0,0); 
            glTexCoord2f(1,1); glVertex2f(100,0);
            glTexCoord2f(1,0); glVertex2f(100,100);
            glTexCoord2f(0,0); glVertex2f(0,100);
        glEnd();
    }
    void Trace()
    {
        age++;
        x+=dX;
        y+=dY;
        
        if(y>=h-100) dY*=-1;
        if(y<=-h) dY*=-1;
        
        if(x>=w-100) dX*=-1;
        if(x<=-w) dX*=-1;
    }
};
 
typedef std::shared_ptr<Fish> FishPtr;
typedef std::list<Fish> FishList;
FishList fishes;
 
void SKeyboard(int key, int x, int y)
{
    int delta = 5;
    switch(key)
    {
        case GLUT_KEY_LEFT:
            speed+=delta;
            break;
        case GLUT_KEY_RIGHT:
            speed-=delta;
            break;
    }
 
    if (speed < 0)
        speed = 0;
}
int fps = 0;
DWORD lastTime = 0;
void Draw()
{
    fps++;
    DWORD time = ::timeGetTime();
    if (time - lastTime > 1000)
    {
        std::cout << "fps: " << fps << std::endl;
        lastTime = time;
        fps = 0;
    }
    glClear(GL_COLOR_BUFFER_BIT);
    for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
    {
        Fish& fish = (*iter);
        glPushMatrix();
        fish.Draw();
        glPopMatrix();
    }
    glutSwapBuffers();
    //glFlush();
}
 
void Collision(const Fish& a, const Fish& b) {
    if(a.predator==true && b.predator==false) {
        //ab.del(b);
    }
    if(b.predator==true && a.predator==false) {
        //ab.del(a);
    }
    if(a.predator==false && b.predator==false) {
        //ab.add(new Fish(false,(0),(0),0));
        if(counter<=limit) {
            if ((int)fishes.size()<limit)
                fishes.push_back(Fish(false,a.x - b.x,a.y - b.y,0));
        }
    }
    if(a.predator==true && b.predator==true) {
        //ab.add(new Fish(true,(0),(0),2));
        if(counter<limit) {
            //Fish ttt(false,a.x - b.x,a.y - b.y,0);
            if ((int)fishes.size()<limit)
                fishes.push_back(Fish(false,rand()%1-400,rand()%1-200,0));
        }
    }
}
 
void Timer(int = 0)
{
        for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = (*iter);
            for(FishList::iterator iterSecond = iter; iterSecond != fishes.end(); ++iterSecond)
            {
                if (iter == iterSecond)
                    continue;
                Fish& second = (*iterSecond);
                float a1 = (first.x)-(second.x);
                float a2 = (first.y)-(second.y);
                float a3 = (second.x)-(first.x);
                float a4 = (second.y)-(first.y);
                if((((a1<=102) && (a1>=100)) || ((a3<=102) && (a3>=100))) && (((a2>=0) && (a2<=100)) || ((a4>=0) && (a4<=100)))) {
                    first.dX*=-1;
                    second.dX*=-1;
                    Collision(first,second);
                }
                if((((a2<=100) && (a2>=98)) || ((a4<=100) && (a4>=98))) && (((a1>=0) && (a1<=100)) || ((a3>=0) && (a3<=100)))) {
                    first.dY*=-1;
                    second.dY*=-1;
                    Collision(first,second);
                }
            }
        }
        std::vector<FishList::iterator> remove;
        for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = (*iter);
            first.Trace();
            if(first.age >= life) remove.push_back(iter);
        }
 
        for(std::vector<FishList::iterator>::iterator iter = remove.begin(); iter != remove.end(); ++iter)
        {
            fishes.erase(*iter);
        }
 
        srand(time(NULL));
        glutTimerFunc(speed, Timer, 0);
        glutPostRedisplay();
}
 
void main(int argc, char **argv)
{
    fishes.push_back(Fish(true,-200,100,2));
    fishes.push_back(Fish(false,-50,0,0));
    fishes.push_back(Fish(false,150,350,1));
    glutInit(&arg, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB );
    glutInitWindowSize(w,h);
    glMatrixMode(GL_PROJECTION);
    glutInitWindowPosition(100,200);
    glutCreateWindow("Aquarium v4.0");
 
    glClearColor(0.0,0.0,0.0,1.0);
    glLoadIdentity();
    gluOrtho2D(-w,w,-h,h);
 
    glutDisplayFunc(Draw);
    glutTimerFunc(speed, Timer, 0);
    glutSpecialFunc(SKeyboard);
 
    glutMainLoop();
}

#include <windows.h>
 
#include <glut.h>
//#include <GL\GLAux.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
//#pragma comment (lib, "Glaux.lib")
#pragma comment (lib, "Winmm.lib")
#include <list>
#include <vector>
#include <memory>
#include <iostream>
 
int w = 1000;
int h = 600;
int speed = 1;
int limit = 8;
int counter = 0;
int life = 20000;
 
#define DELTA_MOVE (0.5f*10)
#define FISH_SIZE 100.f
 
#include <math.h>
class Vector3{
public:
    float x;
    float y;
    float z;
    Vector3(float x = 0.0f, float y = 0.0f, float z = 0.0f)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
    
    void set(const Vector3& value)
    {
        x = value.x;
        y = value.y;
        z = value.z;
    }
    
    void set(float x, float y, float z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
    
    Vector3 add(const Vector3& value)const
    {
        return Vector3(x + value.x, y + value.y, z + value.z);
    }
    
    Vector3& add(const Vector3& value, Vector3& dst)const
    {
        Vector3& result = dst;
        float rx = x + value.x;
        float ry = y + value.y;
        float rz = z + value.z;
        result.x = rx;
        result.y = ry;
        result.z = rz;
        return result;
    }
    
    Vector3 sub(Vector3& value)const
    {
        return Vector3(x - value.x, y - value.y, z - value.z);
    }
    
    Vector3& sub(const Vector3& value, Vector3& dst)const
    {
        Vector3& result = dst;
        float rx = x - value.x;
        float ry = y - value.y;
        float rz = z - value.z;
        result.x = rx;
        result.y = ry;
        result.z = rz;
        return result;
    }
    
    Vector3 mul(float scalar)const
    {
        return Vector3(x * scalar, y * scalar, z * scalar);
    }
    
    Vector3& mul(float scalar, Vector3& dst)const
    {
        Vector3& result = dst;
        float rx = x * scalar;
        float ry = y * scalar;
        float rz = z * scalar;
        result.x = rx;
        result.y = ry;
        result.z = rz;
        return result;
    }
    
    float dot(const Vector3& value)const
    {
        float result = x*value.x + y*value.y + z*value.z;
        return result;
    }
    
    Vector3 cros(const Vector3& value)const
    {
        /*
         * ijk
         * xyz
         * XYZ
         */
        return Vector3(y*value.z - z*value.y,
            z*value.x - x*value.z,
            x*value.y - y*value.x);
    }
    
    Vector3& cros(const Vector3& value, Vector3& dst)const
    {
        Vector3& result = dst;
        /*
         * ijk
         * xyz
         * XYZ
         */
        float rx = y*value.z - z*value.y;
        float ry = z*value.x - x*value.z;
        float rz = x*value.y - y*value.x;
        result.x = rx;
        result.y = ry;
        result.z = rz;
        return result;
    }
    
    float length()const
    {
        float result = sqrt(x*x + y*y + z*z);
        return result;
    }
    
    float distance(const Vector3& point)const
    {
        return distance(point.x,point.y,point.z);
    }
    
    float distanceSquared(const Vector3& point)const
    {
        return distanceSquared(point.x,point.y,point.z);
    }
    
    float distance(float x, float y, float z)const
    {
        float result = sqrt(distanceSquared(x,y,z));
        return result;
    }
    
    float distanceSquared(float x, float y, float z)const
    {
        float dx = x - this->x;
        float dy = y - this->y;
        float dz = z - this->z;
        float result = dx*dx + dy*dy + dz*dz;
        return result;
    }
    
    float angle(const Vector3& vector)
    {
        float dot = this->dot(vector);
        float thisLength = length();
        float vectorLength = vector.length();
        float cosAngle = dot / (thisLength * vectorLength);
        if (cosAngle > 1)
            cosAngle = 1;
        else if (cosAngle < -1)
            cosAngle = -1;
        float angle = (float)acos(cosAngle);
        return angle;
    }
};
 
#include <algorithm>
#undef min
#undef max
 
class Box{
public:
    Vector3 position;
    float length;   //on x
    float width;        //on y
    float height;   //on z
 
    Box(const Vector3& one, const Vector3& two)
    {
        set(one, two);
    }
    
    Box(float x = 0, float y = 0, float z = 0, float length = 0, float width = 0, float height = 0)
    {
        set(x,y,z,length,width,height);
    }
    
    void set(const Vector3& one, const Vector3& two)
    {
        position.x = std::min(one.x, two.x);
        position.y = std::min(one.y, two.y);
        position.z = std::min(one.z, two.z);
        length = (float)abs(one.x - two.x);
        width = (float)abs(one.y - two.y);
        height = (float)abs(one.z - two.z);
    }
    
    void set(float x, float y, float z, float length, float width, float height)
    {
        this->position.x = x;
        this->position.y = y;
        this->position.z = z;
        this->length = length;
        this->width = width;
        this->height = height;
    }
    
    bool isOverlaped(const Box& box)const;
    bool contains(const Vector3& point)const;
    bool contains(float x, float y, float z)const;
};
 
class OverlapTester
{
public:
    static bool isOverlaped(const Box& box1, const Box& box2);
    static bool isPointInBox(const Box& box, const Vector3& point);
    static bool isPointInBox(const Box& box, float x, float y, float z);
};
 
 
bool Box::isOverlaped(const Box& box)const
{
    return OverlapTester::isOverlaped(*this, box);
}
    
bool Box::contains(const Vector3& point)const
{
    return OverlapTester::isPointInBox(*this, point);
}
    
bool Box::contains(float x, float y, float z)const
{
    return OverlapTester::isPointInBox(*this, x, y, z);
}
    
bool OverlapTester::isOverlaped(const Box& box1, const Box& box2)
{
    return (box1.position.x < box2.position.x + box2.length &&
        box1.position.x + box1.length > box2.position.x &&
        box1.position.y < box2.position.y + box2.width &&
        box1.position.y + box1.width > box2.position.y &&
        box1.position.z < box2.position.z + box2.height &&
        box1.position.z + box1.height > box2.position.z);
}
    
bool OverlapTester::isPointInBox(const Box& box, const Vector3& point)
{
    return box.position.x <= point.x && box.position.x + box.length >= point.x &&
            box.position.y <= point.y && box.position.y + box.width >= point.y &&
            box.position.z <= point.z && box.position.z + box.height >= point.z;
}
    
bool OverlapTester::isPointInBox(const Box& box, float x, float y, float z)
{
    return box.position.x <= x && box.position.x + box.length >= x &&
        box.position.y <= y && box.position.y + box.width >= y &&
        box.position.z <= z && box.position.z + box.height >= z;
}
 
 
class Fish {
public:
    bool predator;
    Box body;
    float age;
    float type;
    Vector3 speed;
    Vector3 impulseSpeed;
    Fish (const Fish& t) {
        predator = t.predator;
        body = t.body;
        age = 0;
        type = t.type;
        speed.set(DELTA_MOVE,DELTA_MOVE,0);
    }
    Fish(bool _predator, float x, float y, float _type) {
        predator = _predator;
        body.position.set(x,y,0);
        body.length = body.width = FISH_SIZE;
        body.height = 1;
        age = 0;
        type = _type;
        rand();
        speed.set((((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE,
            (((float)rand()/RAND_MAX) > 0.5f? 1 : -1)*DELTA_MOVE, 0);
    }
 
    void Draw() {
        glTranslatef(body.position.x,body.position.y,0);
        if(type==0)
            glColor3f(1,1,1);
        else if(type==1)
            glColor3f(0,1,1);
        else
            glColor3f(1,0,0);
        glBegin(GL_QUADS);
            glTexCoord2f(0,1); glVertex2f(0,0); 
            glTexCoord2f(1,1); glVertex2f(FISH_SIZE,0);
            glTexCoord2f(1,0); glVertex2f(FISH_SIZE,FISH_SIZE);
            glTexCoord2f(0,0); glVertex2f(0,FISH_SIZE);
        glEnd();
    }
    void Trace()
    {
        age++;
        if (abs(impulseSpeed.length()) > 0.1)
        {
            speed.set(impulseSpeed);
            impulseSpeed.set(0,0,0);
        }
        body.position.add(speed, body.position);
    }
};
 
typedef std::list<Fish> FishList;
FishList fishes;
Box screenBody;
 
void SKeyboard(int key, int x, int y)
{
    int delta = 5;
    switch(key)
    {
        case GLUT_KEY_LEFT:
            speed+=delta;
            break;
        case GLUT_KEY_RIGHT:
            speed-=delta;
            break;
    }
 
    if (speed < 0)
        speed = 0;
}
int fps = 0;
DWORD lastTime = 0;
void Draw()
{
    fps++;
    DWORD time = ::timeGetTime();
    if (time - lastTime > 1000)
    {
        std::cout << "fps: " << fps << std::endl;
        lastTime = time;
        fps = 0;
    }
    glClear(GL_COLOR_BUFFER_BIT);
    for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
    {
        Fish& fish = (*iter);
        glPushMatrix();
        fish.Draw();
        glPopMatrix();
    }
    glutSwapBuffers();
    //glFlush();
}
 
void Collision(const Fish& a, const Fish& b) {
    if(a.predator==true && b.predator==false) {
        //ab.del(b);
    }
    if(b.predator==true && a.predator==false) {
        //ab.del(a);
    }
    if(a.predator==false && b.predator==false) {
        //ab.add(new Fish(false,(0),(0),0));
        if(counter<=limit) {
            if ((int)fishes.size()<limit)
                fishes.push_back(Fish(false,a.body.position.x - b.body.position.x,
                    a.body.position.y - b.body.position.y,0));
        }
    }
    if(a.predator==true && b.predator==true) {
        //ab.add(new Fish(true,(0),(0),2));
        if(counter<limit) {
            //Fish ttt(false,a.x - b.x,a.y - b.y,0);
            if ((int)fishes.size()<limit)
                fishes.push_back(Fish(true,rand()%1-400,rand()%1-200,0));
        }
    }
}
 
void Timer(int = 0)
{
        for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = (*iter);
            for(FishList::iterator iterSecond = iter; iterSecond != fishes.end(); ++iterSecond)
            {
                if (iter == iterSecond)
                    continue;
                Fish& second = (*iterSecond);
                if (first.body.isOverlaped(second.body))
                {
                    Vector3 dir = first.body.position.sub(second.body.position);
                    float dirLength = dir.length();
                    if (abs(dirLength) < 0.1f)
                        dir.set(1,1,0);
                    dir.mul(DELTA_MOVE/dir.length(), dir);
                    first.impulseSpeed.add(dir, first.impulseSpeed);
                    dir.mul(-1,dir);
                    second.impulseSpeed.add(dir, second.impulseSpeed);
                    Collision(first,second);
                }
            }
            if (!first.body.isOverlaped(screenBody))
            {
                Vector3 dir(screenBody.position.x + screenBody.length/2,
                    screenBody.position.y + screenBody.width/2, 0);
                dir.sub(first.body.position, dir);
                dir.mul(DELTA_MOVE/dir.length(), dir);
                first.impulseSpeed.add(dir, first.impulseSpeed);
            }
        }
        std::vector<FishList::iterator> remove;
        for(FishList::iterator iter = fishes.begin(); iter != fishes.end(); ++iter)
        {
            Fish& first = (*iter);
            first.Trace();
            if(first.age >= life) remove.push_back(iter);
        }
 
        for(std::vector<FishList::iterator>::iterator iter = remove.begin(); iter != remove.end(); ++iter)
        {
            fishes.erase(*iter);
        }
 
        srand(time(NULL));
        glutTimerFunc(speed, Timer, 0);
        glutPostRedisplay();
}
 
void main(int argc, char **argv)
{
    fishes.push_back(Fish(true,-200,100,2));
    fishes.push_back(Fish(false,-50,0,0));
    fishes.push_back(Fish(false,150,350,1));
    glutInit(&arg, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB );
    glutInitWindowSize(w,h);
    glMatrixMode(GL_PROJECTION);
    glutInitWindowPosition(100,200);
    glutCreateWindow("Aquarium v4.0");
 
    glClearColor(0.0,0.0,0.0,1.0);
    glLoadIdentity();
    gluOrtho2D(-w,w,-h,h);
    screenBody.set(-w+FISH_SIZE,-h+FISH_SIZE,-10, w*2-2*FISH_SIZE, h*2-2*FISH_SIZE, 20);
 
    glutDisplayFunc(Draw);
    glutTimerFunc(speed, Timer, 0);
    glutSpecialFunc(SKeyboard);
 
    glutMainLoop();
}

                if (first.body.position.x > (screenBody.position.x + screenBody.length) && first.speed.x > 0)
                    first.speed.x *= -1;
                if (first.body.position.x < screenBody.position.x && first.speed.x < 0)
                    first.speed.x *= -1;
                if (first.body.position.y > (screenBody.position.y + screenBody.width) && first.speed.y > 0)
                    first.speed.y *= -1;
                if (first.body.position.y < screenBody.position.y && first.speed.y < 0)
                    first.speed.y *= -1;