Поздравления

#include <thread>
#include <iostream>
#include <list>
#include <cstdlib>
 
// УСТАНАВЛИВАЕМ ПРАВИЛЬНЫЕ РАЗМЕРЫ СВОЕЙ КОНСОЛИ (иначе все поедет)
#define WIDTH 120
#define HEIGHT 30
 
class Surface
{
    const int width = WIDTH;
    const int height = HEIGHT;
    char data[WIDTH * HEIGHT + 1];
 
public:
 
    Surface()
    {
        std::fill(data, data + WIDTH * HEIGHT, ' ');
        data[WIDTH * HEIGHT] = 0;
    }
 
    void clear(char c = ' ')
    {
        std::fill(data, data + WIDTH * HEIGHT, c);
    }
 
    void draw(char c, int x, int y)
    {
        data[y * WIDTH + x] = c;
    }
 
    void draw(char c, int index)
    {
        data[index] = c;
    }
 
    void draw(char* data, int width, int height, int x, int y)
    {
        for(int xw = 0; xw < width; ++xw)
            for(int yh = 0; yh < height; ++yh)
                draw(data[yh * width + xw], x + xw, y + yh);
    }
 
    char getData(int x, int y)
    {
        return data[y * WIDTH + x];
    }
 
    void blit()
    {
        std::cout << data;
    }
 
    void blit(Surface* surface)
    {
        int i = 0;
        for(auto d : data)
        {
            if(d != ' ')
                surface->draw(d, i);
            ++i;
        }
    }
};
 
class Emitter
{
    class Particle
    {
        float x;
        float y;
        float speed;
 
    public:
 
        Particle(int x, int y, float speed) : x(x), y(y), speed(speed) {}
 
        void update(float dt)
        {
            y += speed * dt;
        }
 
        void draw(Surface* s)
        {
            s->draw('*', x, y);
        }
 
        bool isDead(int groundHeight, Surface* surfAccumulated)
        {
            if(y < groundHeight - 1)
            {
                if(surfAccumulated->getData(x, y + 1) != ' ')
                    return true;
            }
 
            if(y >= groundHeight - 1)
                return true;
 
            return false;
        }
    };
 
    std::list<Particle*> particles;
    Surface* surfAccumulated;
 
public:
 
    Emitter(Surface* surfAccumulated) : surfAccumulated(surfAccumulated) {}
 
    void update(float dt)
    {
        std::list<Particle*> toRemove;
 
        if(rand() % 100 < 25)
        {
            Particle* p = new Particle(rand() % WIDTH, 0, rand() % 100 + 50);
            particles.push_back(p);
        }
 
        for(auto p : particles)
        {
            p->update(dt);
            if(p->isDead(HEIGHT, surfAccumulated))
                toRemove.push_back(p);
        }
 
        for(auto p : toRemove)
        {
            p->draw(surfAccumulated);
            particles.remove(p);
            delete p;
        }
    }
 
    void draw(Surface* s)
    {
        for(auto p : particles)
            p->draw(s);
    }
};
 
void clear()
{
    system("cls || clear");
}
 
int main()
{
    Surface surf;
    Surface surfAccumulated;
    Emitter emitter(&surfAccumulated);
 
    char* fir =
        "   ^   "
        "  / \\  "
        " / _ \\ "
        "  / \\  "
        " /   \\ "
        "/__ __\\"
        "   T   "
        "   I   ";
 
    char* stars = new char[WIDTH * HEIGHT];
    std::fill(stars, stars + WIDTH * HEIGHT - 1, ' ');
 
    for(int y=0;y<HEIGHT / 3 * 2; ++y)
        for(int x = 0; x < WIDTH; ++x)
            if(rand() % 100 < 2)
                stars[y * WIDTH + x] = '.';
 
    surfAccumulated.draw(fir, 7, 8, WIDTH / 2, HEIGHT - 8);
 
    while(true)
    {
        clear();
        surf.clear();
 
        surf.draw(stars, WIDTH, HEIGHT, 0, 0);
 
        emitter.update(10.0f / 1000.0f);
        emitter.draw(&surf);
 
        surfAccumulated.blit(&surf);
        surf.blit();
 
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
 
    return 0;
}