C++ ਵਿੱਚ ਕੰਸੋਲ roguelike

ਜਾਣ ਪਛਾਣ

"ਲੀਨਕਸ ਖੇਡਾਂ ਲਈ ਨਹੀਂ ਹੈ!" - ਇੱਕ ਪੁਰਾਣਾ ਵਾਕੰਸ਼: ਹੁਣ ਖਾਸ ਤੌਰ 'ਤੇ ਇਸ ਸ਼ਾਨਦਾਰ ਪ੍ਰਣਾਲੀ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਸ਼ਾਨਦਾਰ ਖੇਡਾਂ ਹਨ. ਪਰ ਫਿਰ ਵੀ, ਕਦੇ-ਕਦੇ ਤੁਸੀਂ ਕੁਝ ਖਾਸ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਅਨੁਕੂਲ ਹੋਵੇ... ਅਤੇ ਮੈਂ ਇਸ ਵਿਸ਼ੇਸ਼ ਚੀਜ਼ ਨੂੰ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ।

ਆਧਾਰ

ਮੈਂ ਪੂਰਾ ਕੋਡ ਨਹੀਂ ਦਿਖਾਵਾਂਗਾ ਅਤੇ ਨਹੀਂ ਦੱਸਾਂਗਾ (ਇਹ ਬਹੁਤ ਦਿਲਚਸਪ ਨਹੀਂ ਹੈ) - ਸਿਰਫ਼ ਮੁੱਖ ਨੁਕਤੇ।

1. ਅੱਖਰ

ਸਾਰੇ ਅੱਖਰ ਪੈਰਾਮੀਟਰ ਇੱਥੇ ਸੂਚੀਬੱਧ ਕੀਤੇ ਗਏ ਹਨ (ਸਿਹਤ, ਸ਼ਸਤ੍ਰ, ਅਨੁਭਵ, ਆਦਿ) ਦਿਲਚਸਪੀ ਦੀ ਗੱਲ ਹੈ ਡਰਾਇੰਗ ਅਤੇ ਅੰਦੋਲਨ ਦੀ ਦਿਸ਼ਾ (ਜੋ ਕਿ ਇਸ ਵੇਲੇ ਉਪਲਬਧ ਨਹੀਂ ਹੈ)।

int x = 5, y = 5;
    hp = 100,
    maxhp = 100,
    dm    = 20,
    armor = 0,
    xp    = 0,
    level = 0,
    diff  = 10, // сложность
    pos   = 0; // направление

bool reg = 0,
       Mdm = 0, // бонусы
       ght = 0;

string color; // цвет будет использован в качестве индикатора состаяния героя

void hero()  // здесь происходит перемещение героя на координаты (x ; y)
{
  cout << "e[u " << "e[0;0H"; // восстановление позиции курсора, затирание пробелом
  for (int i = 0; i <= x; i++)
    cout << RIGHT;              // макрос "e[1C"
  for (int i = 0; i <= y; i++)
    cout << DOWN;             // макрос "e[1B"
  cout << "e[s" << color << "╬"; // сохранение позиции курсора
}

2. ਪ੍ਰਬੰਧਨ

ਅੱਖਰ ਨੂੰ ਕਿਵੇਂ ਮੂਵ ਕਰਨਾ ਹੈ ਪਹਿਲਾਂ ਹੀ ਸਪਸ਼ਟ ਹੈ (x—++, y—++)। ਪਰ ਕੀਬੋਰਡ ਪ੍ਰੋਸੈਸਿੰਗ ਵਧੇਰੇ ਦਿਲਚਸਪ ਹੈ:

char key;
char getkey()
{
  system("stty raw");
  key = getchar();
  system("stty cooked");
  return key;
}

ਜੋ ਕੁਝ ਰਹਿੰਦਾ ਹੈ ਉਹ "ਨਿਯੰਤਰਣ ਅੱਖਰ" ਨੂੰ ਸੈੱਟ ਕਰਨਾ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਸਵਿੱਚ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਮੈਨੂੰ ਇਸ ਤੋਂ ਨਫ਼ਰਤ ਹੈ।

switch(...) case .. : ... ; break ਇਸ ਤਰ੍ਹਾਂ ਬਿਹਤਰ

#define KEY if (key ==
#define I ){
#define J ;}else

void keys()
{
  getkey();
    KEY 'a' I x-- ; pos = 1 J
    KEY......
}

ਸੁੰਦਰਤਾ! ਲੂਪ ਫੰਕਸ਼ਨ ਅਤੇ ਸਕ੍ਰੀਨ ਦੇ ਆਲੇ ਦੁਆਲੇ ਦੌੜੋ! ਪਰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਹ ਥੋੜਾ ਕਠੋਰ ਹੈ... ਅਤੇ ਕਰਸਰ ਚਮਕਦਾ ਹੈ, ਅਤੇ ਅੱਖਰ... ਅਸੀਂ ਇਸਨੂੰ ਠੀਕ ਕਰਾਂਗੇ!

//До цикла
  cout << "e[?25l"; //отключаем отображение курсора
  system("stty -echo"); //отключаем эхо-ввод
  system("xset r rate 120 10"); // изменяем задержку на более плавную
//После цикла
//-------Return_normal_system_settings--------
  cout << "e[00m";
  system("reset");
  system("xset r rate 200 20");

ਵਾਹ! ਇੱਕ ਪ੍ਰਤੀਸ਼ਤ ਤਿਆਰ ਹੈ!

3.ਸਾਡੇ ਆਲੇ ਦੁਆਲੇ ਦੀ ਦੁਨੀਆ

ਇੱਥੇ ਅਸੀਂ ਸੰਸਾਰ ਦੇ x, y ਟੁਕੜਿਆਂ ਅਤੇ ਆਪਣੇ ਆਪ ਦੇ ਟੁਕੜਿਆਂ ਲਈ ਐਰੇ ਬਣਾਉਂਦੇ ਹਾਂ (char o[N]), ਰਾਖਸ਼ਾਂ ਅਤੇ ਬੋਨਸ ਲਈ ਸਮਾਨ।

ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਓ world(int objx[N] .... objy[N] ... obj[N], ... objcolor[N]) ਨਾਲ ਸਮਾਨਤਾ ਦੁਆਰਾ hero(), ਪਰ ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਐਰੇ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨ ਲਈ ਇੱਕ ਵਾਧੂ ਲੂਪ ਦੇ ਨਾਲ... ਮਨੋਰੰਜਨ ਲਈ, ਅਸੀਂ ਸਿਰਫ ਦ੍ਰਿਸ਼ ਦੇ ਖੇਤਰ ਵਿੱਚ ਖਿੱਚਦੇ ਹਾਂ (ਵਿਸ) (if (ox[k] < vis && oy[k]....))

ਹੁਣ ਅਸੀਂ ਕਮਰਿਆਂ ਅਤੇ ਪੈਸਿਆਂ ਲਈ ਸਧਾਰਨ ਅਤੇ ਵਿਧੀਪੂਰਵਕ ਖੋਖਲੇ ਆਊਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੰਸਾਰ ਦੇ ਕਣਾਂ ਨਾਲ ਸਕਰੀਨ ਨੂੰ ਭਰਦੇ ਹਾਂ, ਉਸੇ ਸਮੇਂ ਅਸੀਂ ਦੁਸ਼ਮਣਾਂ ਅਤੇ ਵਸਤੂਆਂ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹਾਂ, ਪੂਰੀ ਬੇਤਰਤੀਬਤਾ ਲਈ ਅਸੀਂ ਇਸ ਬਾਰੇ ਨਹੀਂ ਭੁੱਲਦੇ. srand(time(NULL));

//------------------GENERATION---------------
void rooms()
{
  for (int i = 0; i <= 50; i++)
  {
    px[i] = rand() % 115 + 2;
    py[i] = rand() % 34 + 2;
    pl[i] = rand() % 5 + 5;
    ph[i] = rand() % 5 +  5;

    if (px[i] + pl[i] > 117) px[i] = 50 - pl[i] / 2; else
    if (px[i] < 2)           px[i] = 50 - pl[i] / 2; else
    if (py[i] < 1)           py[i] = 15 - ph[i] / 2; else
    if (py[i] + ph[i] > 37)  py[i] = 15 - ph[i] / 2;

    for (int j = 0; j <= i; j++)
    {
      while (px[i] > px[j] && px[i] < px[j] + pl[j])
        (px[i]+pl[i]/2 >= 55) ? px[i]++ : px[i]-- ;

      while (py[i] > py[j] && py[i] < py[j] + ph[j])
        (py[i]+ph[i]/2 >= 18) ? py[i]++ : py[i]-- ;

      while (px[i]+pl[i] > px[j] && px[i]+pl[i] < px[j] + pl[j])
        (px[i]+pl[i]/2 >= 55) ? px[i]++ : px[i]-- ;

      while (py[i]+ph[i] > py[j] && py[i]+ph[i] < py[j] + ph[j])
        (py[i]+ph[i]/2 >= 18) ? py[i]++ : py[i]-- ;
    }

    for (int j = 0; j <= i; j++)
    {
      while (px[j] + pl[j] >= 116) px[j]-- ;
      while (px[j] < 2)            px[j]++ ;
      while (py[j] < 1)            py[j]++ ;
      while (py[j] + ph[j] >= 37)  py[j]-- ;
    }
    tx[i] = px[i]+10; ty[i] = py[i]-3;

    if (i <= diff)
    {
      ex[i]  = px[i];
      ey[i]  = py[i];
      while (ex[i] < 10){ ex[i]++ ; epos[i] = 3 ;}
      while (ey[i] < 10){ ey[i]++ ; epos[i] = 1 ;}
      e[i]   = evar[pl[i]];
      ecolor[i] = "e[00me[31m";

      edm[i] = edmvar[pl[i]];
      ehp[i] = ehpvar[pl[i]];
      exp[i] = expvar[pl[i]];
    }
    rect(px[i], py[i], pl[i], ph[i]);
  }
}

void corrs()
{
  int pc, px, py;
  for (int i = 0; i <= 4; i++)
  {
    if (i < 2){
      px = 3;
      py = rand() % 33 + 3;
      pc = 110;
      line(px, py, pc, true);
      line(px, py+1, pc, true);
    } else {
      px = rand() % 100 + 3;
      py = 3;
      pc = 33;
      line(px, py, pc, false);
      line(px+1, py, pc, false);
    }
  }
}

4. ਇੰਟਰਐਕਸ਼ਨ

ਹੁਣ ਸਾਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਕੰਧਾਂ ਅਤੇ ਰਾਖਸ਼ਾਂ ਵਿੱਚੋਂ ਲੰਘਣ ਤੋਂ ਬਚਣ ਅਤੇ ਚੀਜ਼ਾਂ ਤੋਂ ਬੋਨਸ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਸਾਡੇ ਮਨਪਸੰਦ ਲਈ ਅਤੇ # ਪਰਿਭਾਸ਼ਿਤ ਹਨ

#define TOUCH if (x == ox[i] && y == oy[i] && pos ==
#define HIT   x == ex[i] && y == ey[i] && pos ==
 for (int i = 0; i <= n; i++)
  {
    if (i <= diff)
    {
     if (Mdm) ehp[i]-=2 ; // если бонус "массовый урон" включен
     epos[i] = 0;

     if (ex[i] < x+5 && ex[i] > x-5 &&
         ey[i] < y+5 && ey[i] > y-5  )
     {
       edel(i); // функция переписывающая предыдущее положение противника
       if (ex[i] < x I ex[i]++ ; epos[i] = 1 J
       if (ex[i] > x I ex[i]-- ; epos[i] = 2 J
       if (ey[i] < y I ey[i]++ ; epos[i] = 3 J
       if (ey[i] > y I ey[i]-- ; epos[i] = 4 ;}
     }
   for (int j = 0; j <= n; j++) // столкновение моба со стенками
       while (ex[i] == ox[j] && ey[i] == oy[j] || ex[i] == ex[j] && ey[i] == ey[j] && j != i)
       {
         if (epos[i] == 1) ex[i]-- ; else
         if (epos[i] == 2) ex[i]++ ; else
         if (epos[i] == 3) ey[i]-- ; else
         if (epos[i] == 4) ey[i]++ ;
       }

     if (x == ex[i] && y == ey[i]) //  "битва"
      {
       if (ehp[i] > 1)
       {
         ehp[i] -= dm;
         (edm[i] < armor) ?
         hp -= 0 :
         hp -= edm[i]-armor;
       } else {
         ex[i] = ey[i] = -1;
         xp += exp[i];
         ehp[i] = 12;
       }
     }
     if (!ght) // если не призрак проверять столкновение игрока с врагами
     {
       if (HIT 1) y++ ;else
       if (HIT 2) x-- ;else
       if (HIT 3) y-- ;else
       if (HIT 4) x++ ;
     }
    }
    if (!ght) // то же, но со стенами
    {
      TOUCH 1 I y++ J
      TOUCH 2 I x-- J
      TOUCH 3 I y-- J
      TOUCH 4 ) x++ ;
    }
  }

5. ਮੀਨੂ

ਅਸੀਂ ਸਿਰਫ਼ ਮੀਨੂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਆਈਟਮਾਂ ਨੂੰ ਨੰਬਰ ਦਿੰਦੇ ਹਾਂ, ਅਤੇ ਖਿਡਾਰੀ ਦੀ ਚੋਣ 'ਤੇ ਕਾਰਵਾਈ ਕਰਨ ਲਈ getkey() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਅੱਖਰ ਦੀ ਸਥਿਤੀ ਪੱਟੀ ਲਿਖਦੇ ਹਾਂ, ਲੈਵਲਿੰਗ ਮੀਨੂ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਾਂ, ਬੈਕ ਸਟੋਰੀ ਲਿਖਦੇ ਹਾਂ, ਅਤੇ ਸਾਨੂੰ ਉਹ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ਜਿਸਨੂੰ ਮੈਂ "ਸਬਸਾਇਲ" ਕਿਹਾ ਸੀ।

ਸਿੱਟਾ

ਇਹ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ ਡਾਊਨਲੋਡ ਕੀਤਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਅਨਪੈਕ ਕਰਨਾ ਅਤੇ ਚੱਲ ਰਿਹਾ ਹੈ:

$ sudo chmod +x Subsoil-1.0/Subsoil

$ Subsoil-1.0/Subsoil

, ਜਾਂ, ਅੰਤ ਵਿੱਚ ਪ੍ਰੇਰਿਤ ਹੋ ਕੇ, ਆਪਣੇ ਆਪ ਨੂੰ ਆਪਣੀ ਪਸੰਦ ਦਾ ਇੱਕ ਸਾਹਸ ਲਿਖੋ। ਮੈਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਚੇਤਾਵਨੀ ਦਿੰਦਾ ਹਾਂ: ਮੇਰੀ ਖੇਡ ਆਸਾਨ ਨਹੀਂ ਹੈ!

ਲਿੰਕ

ਵਿਧੀਗਤ ਪੀੜ੍ਹੀ, ਉਤਸ਼ਾਹਿਤ ਕਰਨ ਵਾਲਾ.

ਸਰੋਤ: www.habr.com