Движение графики

#include <iostream>
#include <graphics.h>
int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "");  // Инициализация графического режима
    settextstyle(DEFAULT_FONT, HORIZ_DIR, 3);  // Установка стиля текста
    int x = 0, y = 0;
    int step = 5;
    int directionX = 1;
    int directionY = 1;
 
    while (1) {
        cleardevice();  // Очистка экрана
 
        outtextxy(x, y, "Мансуров");  // Отображение текста
 
        delay(100);  // Задержка в 100 миллисекунд
 
        // Обновление координат текста в зависимости от направления движения
        if (x + textwidth("Мансуров") <= getmaxx() && y + textheight("Мансуров") <= getmaxy() && x >= 0 && y >= 0) {
            // Движение с левого верхнего угла на правый нижний угол
            x += step * directionX;
            y += step * directionY;
        }
        else if (x + textwidth("Мансуров") <= getmaxx() && y + textheight("Мансуров") > getmaxy() && x >= 0) {
            // Движение с правого нижнего угла в верхний правый угол
            x += step * directionX;
            y -= step * directionY;
        }
        else if (x >= 0 && y + textheight("Мансуров") <= getmaxy() && y >= 0) {
            // Движение с верхнего правого угла в левый нижний угол
            x -= step * directionX;
            y += step * directionY;
        }
        else {
            break;  // Завершение программы после возврата в начальную позицию
        }
    }
 
    closegraph();
 
    return 0;
}

void TForm1::MoveText(String text, String from, String to, double step, int delay)
{
  const int n = 9;
 
  int text_w = Canvas->TextWidth(text), text_h = Canvas->TextHeight(text),
      x1, y1, x2, y2, xw = ClientWidth - text_w, yh = ClientHeight - text_h;
  String dir[n] = {"NW", "NE", "SW", "SE",    "W",    "N",    "E",    "S",    "C"};
  int      x[n] = {   0,   xw,    0,   xw,      0, xw / 2,     xw, xw / 2, xw / 2},
           y[n] = {   0,    0,   yh,   yh, yh / 2,      0, yh / 2,     yh, yh / 2};
 
  bool a = false, b = false;
  for (int i = 0; i < n; i++)
  {
    if (from == dir[i] & !a)
      x1 = x[i], y1 = y[i], a = true;
    if (to == dir[i] & !b)
      x2 = x[i], y2 = y[i], b = true;
    if (a & b)
      break;
  }
 
  double dist_x = x2 - x1, dist_y = y2 - y1,
         dist = hypot(dist_x, dist_y), angle = atan2(dist_x, dist_y),
         tmp_x, tmp_y, sin_a = sin(angle), cos_a = cos(angle);
  for (double j = 0; j <= dist; j += step)
  {
    Refresh();
    tmp_x = x1 + j * sin_a;
    tmp_y = y1 + j * cos_a;
    Canvas->TextOutW(tmp_x, tmp_y, text);
    SleepEx(delay, true);
    Application->ProcessMessages();
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonClick(TObject *Sender)
{
  Button->Visible = 0;
 
  const int num = 5;
  String text = "я у мамы Пикачу", from, to,
         dir[num] = {"NW", "SE", "NE", "SW", "N"};  // первый вариант движения
  // String dir[num] = {"NW", "NE", "SW", "SE", "W"};  // второй вариант движения
 
  double step = 10;  // или 2
  int delay = step * 4;  // или * 10
 
  for (int i = 1; i < num; i++)
  {
    from = dir[i - 1];
    to = dir[i];
    MoveText(text, from, to, step, delay);
  }
 
  Button->Visible = 1;
}

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
 
#include <graphics.h>
 
const int BORDER = 9999;
 
struct  Coord
{
    int x, y;
};
 
struct  Rebro
{
    Coord     dir;
    Coord       s;
    int speed = 1;
 
    void debug() const
    {   std::cout << "  dir: " << std::setw(4) << dir.x << ", "
                               << std::setw(4) << dir.y << '\n';
        std::cout << "  s  : " << std::setw(4) <<   s.x << ", "
                               << std::setw(4) <<   s.y << "\n\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Тестовый объект.
///----------------------------------------------------------------------------:
struct  Object
{       Object(const char* ss = "Мансуров") : s(ss)
        {
            width  = textwidth (s.data());
            height = textheight(s.data());
        }
 
    Coord coord{50, 50};
 
    void show()
    {   outtextxy(coord.x, coord.y, s.data());
    }
 
    bool isout()
    {   return coord.x + width  > getmaxx() ||
               coord.y + height > getmaxy() || coord.x < 0 || coord.y < 0;
    }
 
private:
    int     width;
    int    height;
    std::string s;
};
 
///----------------------------------------------------------------------------|
/// Двигатель.
///----------------------------------------------------------------------------:
struct  Mover
{
    void go(){ go_step(); po->show(); }
 
    std::vector<Rebro> mymap;
 
    void set_obj(Object* o)
    {    po  = o;
         itr = mymap.begin();
         init_rebro();
    }
 
    void debug() const
    {   for(const auto& r : mymap)
        {   r.debug();
        }
    }
 
private:
    int  dx;
    int  dy;
 
    int adx;
    int ady;
 
    Coord s;
 
    std::vector<Rebro>::iterator itr;
 
    Object* po;
 
    void init_rebro()
    {
        const auto& rebro = *itr;
 
        s = {0, 0};
 
        dx  = rebro.dir.x * rebro.speed;
        dy  = rebro.dir.y * rebro.speed;
 
        adx = std::abs(dx);
        ady = std::abs(dy);
    }
 
    bool go_step()
    {
        if(itr == mymap.end()) return false;
 
        const auto& rebro = *itr;
 
        if( !(s.x < rebro.s.x &&
              s.y < rebro.s.y && !po-> isout()) )
        {
            if(++itr != mymap.end())
            {
                po->coord.x -= dx;
                po->coord.y -= dy;
                init_rebro();
            }
            else return false;
        }
 
        {   po->coord.x += dx;
            po->coord.y += dy;
 
            s.x += adx;
            s.y += ady;
        }
 
        return true;
    }
};
 
///----------------------------------------------------------------------------|
/// main.
///----------------------------------------------------------------------------:
int main()
{
    ///-----------------------|
    /// Технология...         |
    ///-----------------------:
    int gd = DETECT,  gm;
    initgraph ( &gd, &gm, (char*)"");
    settextstyle(DEFAULT_FONT, HORIZ_DIR, 3);
 
    std::cout << "Start ...\n";
 
    ///-----------------------|
    /// Объекты.              |
    ///-----------------------:
    Object  object0;
    Object  object1("Собака");
    Object  object2("Кот");
 
    ///-----------------------|
    /// Двигатель.            |
    ///-----------------------:
    Mover    movers[3];
 
    ///-----------------------|
    /// Даём машрут.          |
    ///-----------------------:
    {       ///-------------|
            /// Мансуров.   |
            ///-------------:
            movers[0].mymap =
            {
                {   { 1, 0}, {BORDER, BORDER}, 5
                },
                {   {-1, 1}, {BORDER, BORDER}, 1
                },
                {   { 1, 0}, {BORDER, BORDER}, 5
                },
                {   {-2,-1}, {BORDER, BORDER}, 1
                }
            };
 
            ///-------------|
            /// Собака.     |
            ///-------------:
            movers[1].mymap =
            {
                {   { 0, 1}, {BORDER, BORDER}, 1
                },
                {   { 1,-1}, {BORDER, BORDER}, 2
                },
                {   {-1, 0}, {BORDER, BORDER}, 3
                },
                {   {0,  1}, {BORDER, BORDER}, 4
                }
            };
 
            ///-------------|
            /// Кот.        |
            ///-------------:
            movers[2].mymap =
            {
                {   { 1, 1}, {BORDER, BORDER}, 1
                },
                {   { 0,-1}, {BORDER, BORDER}, 3
                },
                {   {-1, 0}, {BORDER, BORDER}, 1
                },
                {   { 0, 1}, {BORDER, BORDER}, 3
                },
                {   { 1,-1}, {BORDER, BORDER}, 3
                }
            };
 
            //movers[0].debug();
    }
 
    ///-----------------------|
    /// Что двигаем?.         |
    ///-----------------------:
    movers[0].set_obj(&object0);
    movers[1].set_obj(&object1);
    movers[2].set_obj(&object2);
 
    std::cin.get();
 
    ///-----------------------|
    /// Поехали...            |
    ///-----------------------:
    while(true)
    {
        cleardevice();
 
        for(auto& mover : movers) mover.go();
 
        delay    (20);
    }
 
    ///-----------------------|
    /// Пауза.                |
    ///-----------------------:
    std::cin.get();
    closegraph  ();
}

void TForm1::MoveText(String text, String from, String to, double step, int delay)
{
  const int n = 9;
 
  int text_w = Canvas->TextWidth(text), text_h = Canvas->TextHeight(text),
      x1, y1, x2, y2, xw = ClientWidth - text_w, yh = ClientHeight - text_h;
  String dir[n] = {"NW", "NE", "SW", "SE",    "W",    "N",    "E",    "S",    "C"};
  int      x[n] = {   0,   xw,    0,   xw,      0, xw / 2,     xw, xw / 2, xw / 2},
           y[n] = {   0,    0,   yh,   yh, yh / 2,      0, yh / 2,     yh, yh / 2};
 
  bool a = false, b = false;
  for (int i = 0; i < n; i++)
  {
    if (from == dir[i] & !a)
      x1 = x[i], y1 = y[i], a = true;
    if (to == dir[i] & !b)
      x2 = x[i], y2 = y[i], b = true;
    if (a & b)
      break;
  }
 
  double dist_x = x2 - x1, dist_y = y2 - y1,
         dist = hypot(dist_x, dist_y), angle = atan2(dist_x, dist_y),
         tmp_x, tmp_y, sin_a = sin(angle), cos_a = cos(angle);
  for (double j = 0; j <= dist; j += step)
  {
    Update();
    tmp_x = x1 + j * sin_a;
    tmp_y = y1 + j * cos_a;
    text = TimeToStr(Time()) + "." + String(MilliSecondOf(Time()) / 100);
    Canvas->TextOutW(tmp_x, tmp_y, text);
    SleepEx(delay, true);
    Application->ProcessMessages();
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonClick(TObject *Sender)
{
  Refresh();
  Button->Visible = 0;
  Tag = 1;
 
  randomize();
 
  const int num = 9;
  String text, from, to,
         dir[num] = {"NW", "NE", "SW", "SE", "W", "N", "E", "S", "C"};
 
  double step = 1;
  int delay = step * 4;
 
  int tmp = random(num);
  from = dir[tmp];
  int count = 1000;
  for (int i = 0; i < count; i++)
  {
    if (!Tag)
      break;
 
    for (int j = 0; j < num; j++)
      if (from == dir[j])
      {
        tmp = j;
        break;
      }
    to = dir[(tmp + random(num - 1) + 1) % num];
    text = TimeToStr(Time()) + "." + String(MilliSecondOf(Time()) / 100);
    Color = TColor(rand());
    MoveText(text, from, to, step, delay);
    from = to;
  }
 
  Button->Visible = 1;
  Tag = 0;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y)
{
  Tag = 0;
}