Как сделать движущуюся модельку?

#include <windows.h>
 
#include <chrono>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
HANDLE GetConsoleHandle()
{
    return GetStdHandle(STD_OUTPUT_HANDLE);
}
 
void GoToXY(unsigned x, unsigned y)
{
    COORD coord = { static_cast<SHORT>(x), static_cast<SHORT>(y) };
    SetConsoleCursorPosition(GetConsoleHandle(), coord);
}
 
class ScreenBuffer
{
    int m_width;
    int m_height;
    std::string m_buffer;
 
public:
    ScreenBuffer(int width, int height)
        : m_width(width)
        , m_height(height)
    {
        const int size = (m_width + 1) * m_height;
        m_buffer.resize(size);
        Clear();
    }
 
    int GetWidth()
    {
        return m_width;
    }
 
    int GetHeight()
    {
        return m_height;
    }
 
    void Fill(char ch)
    {
        for (size_t i = 0, end = m_buffer.size(); i != end; ++i)
            m_buffer[i] = ch;
 
        for (size_t i = 1, end = m_height; i <= end; ++i)
        {
            m_buffer[(i * (m_width + 1)) - 1] = '\n';
        }
    }
 
    void Clear()
    {
        Fill(' ');
    }
 
    void Draw(int x, int y, char ch)
    {
        m_buffer[y * (m_width + 1) + x] = ch;
    }
 
    void Draw(double x, double y, char ch)
    {
        Draw(int(x), int(y), ch);
    }
 
    void DrawToScreen() const
    {
        GoToXY(0, 0);
        std::cout << m_buffer;
    }
};
 
void DrawBorder(ScreenBuffer& screen)
{
    const int screenWidth = screen.GetWidth();
    const int screenHeight = screen.GetHeight();
 
    for (int i = 0; i < screenWidth; ++i)
    {
        screen.Draw(i, 0, '.');
        screen.Draw(i, screenHeight - 1, '.');
    }
 
    for (int i = 0, end = screen.GetHeight(); i != end; ++i)
    {
        screen.Draw(0, i, '.');
        screen.Draw(screenWidth - 1, i, '.');
    }
}
 
struct Object
{
    double x;
    double y;
    int width;
    int height;
    double xSpeed;
    double ySpeed;
 
    virtual void Draw(ScreenBuffer& screen) = 0;
    virtual ~Object() {};
 
    Object()
        : x(0)
        , y(0)
        , width(0)
        , height(0)
        , xSpeed(0)
        , ySpeed(0)
    {
    }
};
 
class Rect : public Object
{
public:
    Rect(int w, int h, char ch)
        : symbol(ch)
    {
        width = w;
        height = h;
    }
 
    void Draw(ScreenBuffer& screen)
    {
        for (int i = 0; i < width; ++i)
        {
            screen.Draw(x + i, y, symbol);
            screen.Draw(x + i, y + height - 1, symbol);
        }
 
        for (int i = 0; i < height; ++i)
        {
            screen.Draw(x, y + i, symbol);
            screen.Draw(x + width - 1, y + i, symbol);
        }
    }
 
private:
    char symbol;
};
 
class Cross : public Object
{
public:
    Cross(char ch)
        : symbol(ch)
    {
        width = 3;
        height = 3;
    }
 
    void Draw(ScreenBuffer& screen)
    {
        for (int i = 0; i < width; ++i)
        {
            screen.Draw(x + i, y + 1, symbol);
        }
 
        for (int i = 0; i < height; ++i)
        {
            screen.Draw(x + 1, y + i, symbol);
        }
    }
 
private:
    char symbol;
};
 
void ProcessObject(ScreenBuffer& screen, Object& obj)
{
    obj.x += obj.xSpeed;
    obj.y += obj.ySpeed;
 
    if (obj.x >= screen.GetWidth() - obj.width)
    {
        obj.xSpeed = -obj.xSpeed;
        obj.x = screen.GetWidth() - obj.width - (obj.x - screen.GetWidth() + obj.width);
    }
    else if (obj.x < 0)
    {
        obj.xSpeed = -obj.xSpeed;
        obj.x = -obj.x;
    }
 
    if (obj.y >= screen.GetHeight() - obj.height)
    {
        obj.ySpeed = -obj.ySpeed;
        obj.y = screen.GetHeight() - obj.height - (obj.y - screen.GetHeight() + obj.height);
    }
    else if (obj.y < 0)
    {
        obj.ySpeed = -obj.ySpeed;
        obj.y = -obj.y;
    }
}
 
void AddObjects(std::vector<std::unique_ptr<Object>>& objs)
{
    {
        std::unique_ptr<Object> obj(new Rect(5, 5, '*'));
        obj->xSpeed = 3;
        obj->ySpeed = 1;
        obj->x = 2;
        obj->y = 10;
        objs.push_back(std::move(obj));
    }
 
    {
        std::unique_ptr<Object> obj(new Rect(3, 3, '#'));
        obj->xSpeed = 1;
        obj->ySpeed = 1;
        obj->x = 5;
        obj->y = 1;
        objs.push_back(std::move(obj));
    }
 
    {
        std::unique_ptr<Object> obj(new Cross('+'));
        obj->xSpeed = 1;
        obj->ySpeed = 0.1;
        obj->x = 10;
        obj->y = 1;
        objs.push_back(std::move(obj));
    }
}
 
int main()
{
    const int screenWidth = 60;
    const int screenHeight = 20;
    ScreenBuffer screen(screenWidth, screenHeight);
 
    std::vector<std::unique_ptr<Object>> objs;
    AddObjects(objs);
 
    for (;;)
    {
        screen.Clear();
        DrawBorder(screen);
 
        for (auto& objPtr : objs)
        {
            ProcessObject(screen, *objPtr);
            objPtr->Draw(screen);
        }
 
        screen.DrawToScreen();
 
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
 
    return 0;
}