zombie.cc

#include <math.h>
#include <stdlib.h>
#include <unistd.h>
#include <SDL/SDL.h>
#include <stdio.h>

double rad = 10;
double PI = 3.1415926535;

SDL_Surface *screen;

enum types
{
    human = 0,
    zombie = 1
};

class alive
{
protected:
    double tx, ty, tvx, tvy, tview; //временные величины
    double fx, fy;
public:
    Uint8 color;
    double rad;
    types type;
    double x, y;
    double vx, vy;
    double view;

    double tired;


    double max_tired;

    double max_vel;

    void ready(double dt);

    virtual void react(alive &obj) = 0;
    void walls(double nx, double ny);
    void go(double dt);
};

void alive::go(double dt)
{
    if (max_tired < 0)
        tired = 0;

    double k = 1;
    if (max_tired > 0)
        k = 1-(tired / max_tired)*(tired / max_tired);
    if (k >= 0)
    {
        tvx = fx*k;
        tvy = fy*k;
    }
    else
    {
        tired = 0;
        tvx = 0;
        tvy = 0;
    }

    double vel = sqrt(tvx*tvx + tvy*tvy);
    if (vel > max_vel)
    {
        tvx *= max_vel/vel;
        tvy *= max_vel/vel;
        tired += dt*max_vel;
    }
    else
        tired += dt*(vel+0.1);



}

void alive::ready(double dt)
{
    x = x + tvx*dt;
    y = y + tvy*dt;
    vx = tvx;
    vy = tvy;
    view = tview;
    tvx = 0;
    tvy = 0;
    fx = 0;
    fy = 0;
}


void alive::walls(double nx, double ny) // взаимодействие со стенами
{
    double nr = sqrt(nx*nx+ny*ny);
    nx /= nr;
    ny /= nr;
    double pr = nx*tvx + ny*tvy;
    if (pr < 0) // смотрим в стену
    {
        double vel = sqrt(tvx*tvx + tvy*tvy);
        tvx += -pr*nx*1.1;
        tvy += -pr*ny*1.1;
//      x += 3*nx;
//      y += 3*ny;
        double nvel=sqrt(tvx*tvx + tvy*tvy);
        if (nvel > 1e-6)
        {
            tvx *= vel/nvel;
            tvy *= vel/nvel;
        }
    }

}



class a_human:public alive
{
    public:
        int zombify;
        void react(alive &obj);
        a_human();

};


a_human::a_human()
{
    zombify = 0;
    type = human;
    tired = 0;
    max_tired = 10;
    max_vel = 1;
        color = SDL_MapRGB( screen->format, 0, 255, 0 );
    rad = 0.5;
}

void a_human::react(alive &obj)
{
    double dx = x-obj.x;
    double dy = y-obj.y;
    double l = sqrt(dx*dx+dy*dy);

    switch(obj.type)
    {
        case human:
            if (l > 1e-6 && l < rad + obj.rad)  // взаимодействие
            {
                double dfx = (dx/l)/(l*l);  //отталкивание
                double dfy = (dy/l)/(l*l);

                fx += dfx;
                fy += dfy;
            }
            break;
        case zombie:
            if (l < rad + obj.rad)  // упс, покусали
            {
                zombify = 1;
                printf("Зомбификация!\n");
            }
            else            // убегаем
            {
                double dfx = (dx/l);      //отталкивание
                                double dfy = (dy/l);

                                fx += dfx;
                                fy += dfy;
            }
            break;
    }
}

class a_zombie : public alive
{
    public:
        void react(alive &obj);
        a_zombie();
};


a_zombie::a_zombie()
{
    max_tired = -1;
    type = zombie;
    max_vel = 0.7;
        color = SDL_MapRGB( screen->format, 255, 0, 0 );
    rad = 0.5;
}


void a_zombie::react(alive &obj)
{
    double dx = x-obj.x;
    double dy = y-obj.y;
    double l = sqrt(dx*dx+dy*dy);

    switch(obj.type)
    {
        case zombie:
            if (l > 1e-6 && l < rad + obj.rad)  // взаимодействие
            {
                double dfx = (dx/l)/(l*l);  //отталкивание
                double dfy = (dy/l)/(l*l);

                fx += dfx;
                fy += dfy;
            }
            break;
        case human:
            double dfx = -(dx/l)/(l);      // в погоню!
                        double dfy = -(dy/l)/(l);

                        fx += dfx;
                        fy += dfy;

            break;
    }
}


typedef alive* palive;

palive *mass;
int n = 30;

Uint8 colour_h, colour_z;

void init()
{
    int i;
    mass = new palive[n];
    mass[0] = new a_zombie;
    for (i = 1; i < n; i++)
        mass[i] = new a_human;

    for (i = 0; i < n; i++)
    {
        double r, an;

        r = rand()/((double)RAND_MAX)*rad;
        an = rand()/((double)RAND_MAX)*2*PI;
        mass[i]->x = r*cos(an);
        mass[i]->y = r*sin(an);
    }
}

void deinit()
{
    int i;
    for (i = 0; i < n; i++)
        delete mass[i];
    delete mass;
}

void step(double dt)
{
    int i, j;

    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (i == j)
                continue;
            mass[i]->react(*(mass[j]));
        }
    }
    for (i = 0; i < n; i++)
    {
        mass[i]->go(dt);

        double x, y;
        x = mass[i]->x;
        y = mass[i]->y;
        if (x*x + y*y > rad*rad)
        {
            mass[i]->walls(-x, -y);
        }
        mass[i]->ready(dt);
    }

    for (i = 0; i < n; i++)
    {
        if (mass[i]->type == human && ((a_human*)mass[i])->zombify == 1)
        {
            double x, y, view;
            x = mass[i]->x;
            y = mass[i]->y;
            view = mass[i]->view;
            delete mass[i];
            mass[i] = new a_zombie();
            mass[i]->x = x;
            mass[i]->y = y;
            mass[i]->view = view;
        }
    }
}



void draw_pixel(int X, int Y, Uint8 color, SDL_Surface *screen)
{
        Uint8 *pixmem;
        if (X < 10)
                X = 10;
        if (Y < 10)
                Y = 10;
        if (X >= 890)
                X = 889;
        if (Y >= 890)
                Y = 889;

        pixmem = (Uint8 *)screen->pixels + Y * screen->pitch + X * screen->format->BytesPerPixel;
        *pixmem = color;
}

void draw_per(int i, SDL_Surface *screen)
{
        Uint8 color = mass[i]->color;
        int X, Y;
        double x, y;

        X = mass[i]->x/(rad)*400 + 450;
        Y = mass[i]->y/(rad)*400 + 450;

        draw_pixel(X-1, Y-1, color, screen);
        draw_pixel(X-1, Y, color, screen);
        draw_pixel(X-1, Y+1, color, screen);
        draw_pixel(X, Y-1, color, screen);
        draw_pixel(X, Y, color, screen);
        draw_pixel(X, Y+1, color, screen);
        draw_pixel(X+1, Y-1, color, screen);
        draw_pixel(X+1, Y, color, screen);
        draw_pixel(X+1, Y+1, color, screen);

        int dx = 8*cos(mass[i]->view);
        int dy = 8*sin(mass[i]->view);
        draw_pixel(X+dx, Y+dy, color, screen);
}




void draw_wall()
{
        double an;
        for (an = 0; an < 2*PI; an+=0.001)
        {
                double x = (rad+0.2)*cos(an);
                double y = (rad+0.2)*sin(an);
                int X = x/(rad)*400 + 450;
                int Y = y/(rad)*400 + 450;
                Uint8 color_wall = SDL_MapRGB( screen->format, 255, 255, 0 );
                draw_pixel(X, Y, color_wall, screen);
        }
}


int main()
{
        SDL_Event event;

    SDL_Init(SDL_INIT_VIDEO);
        screen = SDL_SetVideoMode(900, 900,8,SDL_HWSURFACE|SDL_DOUBLEBUF);

//  srand(time(NULL));

    init();

    int keypress = 0;

    double dt = 0.1;
    while(!keypress)
        {
        int i;
        SDL_FillRect(screen, NULL, 0x000000);
        step(dt);
        draw_wall();

                for (i = 0; i < n; i++)
                {
                        draw_per(i, screen);
        }

        SDL_Flip(screen);
                while(SDL_PollEvent(&event))
                {
                        switch (event.type)
                        {
                                case SDL_QUIT:
                                        keypress = 1;
                                        break;
                                case SDL_KEYDOWN:
                                        keypress = 1;
                                        break;
                        }
                }

    }
    deinit();
    SDL_Quit();
    return 0;
}