// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//--------------------------
// Zbiór procedur obsługi konsoli znakowej w Windows
//          (C)2006 mgr Jerzy Wałaszek
//--------------------------------------------------

#include <iostream>
#include <windows.h>
#include <string>
#include "newconio.h"

using namespace std;

__declspec(dllimport) BOOL WINAPI SetConsoleDisplayMode(HANDLE,DWORD,PCOORD);

static WORD   _txattr;
static HANDLE _hcout,_hcin;
static int    _cextend = -1;

//----------------------------------------------------------------------
// Poniższa tablica odwzorowuje wirtualne kody klawiszy Windows na kody
// BIOS dla klawiatury IBM PC. Dla każdego wirtualnego kodu klawisza
// dostępne są cztery wartości BIOS: zwykła, z shift, z Ctrl i z Alt.
// Kombinacje klawiszy nie posiadające odpowiednika BIOS mają wartość
// -1 i są ignorowane. Rozszerzone klawisze (nie ze zbioru ASCII)
// mają ustawiony na 1 bit 8 przy pomocy makra EXT.
//----------------------------------------------------------------------

#define EXT(key)    ((key)+0x100)
#define ISEXT(val)  ((val)&0x100)
#define EXTVAL(val) ((val)&0xff)

struct kbd
{
    short keycode; // kod wirtualny
    short normal;  // normalny kod BIOS
    short shift;   // kod BIOS z shift
    short ctrl;    // kod BIOS z Ctrl
    short alt;     // kod BIOS z Alt
} kbdtab [] =
{
//  wirtualny     normalny   shift       ctrl         alt

  { VK_BACK,      0x08,       0x08,       0x7f,       EXT(14)  },
  { VK_TAB,       0x09,       EXT(15),    EXT(148),   EXT(165) },
  { VK_RETURN,    0x0d,       0x0d,       0x0a,       EXT(166) },
  { VK_ESCAPE,    0x1b,       0x1b,       0x1b,       EXT(1)   },
  { VK_SPACE,     0x20,       0x20,       EXT(3),     0x20,    },
  { '0',          '0',        ')',        -1,         EXT(129) },
  { '1',          '1',        '!',        -1,         EXT(120) },
  { '2',          '2',        '@',        EXT(3),     EXT(121) },
  { '3',          '3',        '#',        -1,         EXT(122) },
  { '4',          '4',        '$',        -1,         EXT(123) },
  { '5',          '5',        '%',        -1,         EXT(124) },
  { '6',          '6',        '^',        0x1e,       EXT(125) },
  { '7',          '7',        '&',        -1,         EXT(126) },
  { '8',          '8',        '*',        -1,         EXT(127) },
  { '9',          '9',        '(',        -1,         EXT(128) },

  { 'A',          'a',        'A',        0x01,       EXT(30)  },
  { 'B',          'b',        'B',        0x02,       EXT(48)  },
  { 'C',          'c',        'C',        0x03,       EXT(46)  },
  { 'D',          'd',        'D',        0x04,       EXT(32)  },
  { 'E',          'e',        'E',        0x05,       EXT(18)  },
  { 'F',          'f',        'F',        0x06,       EXT(33)  },
  { 'G',          'g',        'G',        0x07,       EXT(34)  },
  { 'H',          'h',        'H',        0x08,       EXT(35)  },
  { 'I',          'i',        'I',        0x09,       EXT(23)  },
  { 'J',          'j',        'J',        0x0a,       EXT(36)  },
  { 'K',          'k',        'K',        0x0b,       EXT(37)  },
  { 'L',          'l',        'L',        0x0c,       EXT(38)  },
  { 'M',          'm',        'M',        0x0d,       EXT(50)  },
  { 'N',          'n',        'N',        0x0e,       EXT(49)  },
  { 'O',          'o',        'O',        0x0f,       EXT(24)  },
  { 'P',          'p',        'P',        0x10,       EXT(25)  },
  { 'Q',          'q',        'Q',        0x11,       EXT(16)  },
  { 'R',          'r',        'R',        0x12,       EXT(19)  },
  { 'S',          's',        'S',        0x13,       EXT(31)  },
  { 'T',          't',        'T',        0x14,       EXT(20)  },
  { 'U',          'u',        'U',        0x15,       EXT(22)  },
  { 'V',          'v',        'V',        0x16,       EXT(47)  },
  { 'W',          'w',        'W',        0x17,       EXT(17)  },
  { 'X',          'x',        'X',        0x18,       EXT(45)  },
  { 'Y',          'y',        'Y',        0x19,       EXT(21)  },
  { 'Z',          'z',        'Z',        0x1a,       EXT(44)  },

  { VK_PRIOR,     EXT(73),    EXT(73),    EXT(132),   EXT(153) },
  { VK_NEXT,      EXT(81),    EXT(81),    EXT(118),   EXT(161) },
  { VK_END,       EXT(79),    EXT(79),    EXT(117),   EXT(159) },
  { VK_HOME,      EXT(71),    EXT(71),    EXT(119),   EXT(151) },
  { VK_LEFT,      EXT(75),    EXT(75),    EXT(115),   EXT(155) },
  { VK_UP,        EXT(72),    EXT(72),    EXT(141),   EXT(152) },
  { VK_RIGHT,     EXT(77),    EXT(77),    EXT(116),   EXT(157) },
  { VK_DOWN,      EXT(80),    EXT(80),    EXT(145),   EXT(160) },
  { VK_INSERT,    EXT(82),    EXT(82),    EXT(146),   EXT(162) },
  { VK_DELETE,    EXT(83),    EXT(83),    EXT(147),   EXT(163) },
  { VK_NUMPAD0,   '0',        EXT(82),    EXT(146),   -1       },
  { VK_NUMPAD1,   '1',        EXT(79),    EXT(117),   -1       },
  { VK_NUMPAD2,   '2',        EXT(80),    EXT(145),   -1       },
  { VK_NUMPAD3,   '3',        EXT(81),    EXT(118),   -1       },
  { VK_NUMPAD4,   '4',        EXT(75),    EXT(115),   -1       },
  { VK_NUMPAD5,   '5',        EXT(76),    EXT(143),   -1       },
  { VK_NUMPAD6,   '6',        EXT(77),    EXT(116),   -1       },
  { VK_NUMPAD7,   '7',        EXT(71),    EXT(119),   -1       },
  { VK_NUMPAD8,   '8',        EXT(72),    EXT(141),   -1       },
  { VK_NUMPAD9,   '9',        EXT(73),    EXT(132),   -1       },
  { VK_MULTIPLY,  '*',        '*',        EXT(150),   EXT(55)  },
  { VK_ADD,       '+',        '+',        EXT(144),   EXT(78)  },
  { VK_SUBTRACT,  '-',        '-',        EXT(142),   EXT(74)  },
  { VK_DECIMAL,   '.',        '.',        EXT(83),    EXT(147) },
  { VK_DIVIDE,    '/',        '/',        EXT(149),   EXT(164) },
  { VK_F1,        EXT(59),    EXT(84),    EXT(94),    EXT(104) },
  { VK_F2,        EXT(60),    EXT(85),    EXT(95),    EXT(105) },
  { VK_F3,        EXT(61),    EXT(86),    EXT(96),    EXT(106) },
  { VK_F4,        EXT(62),    EXT(87),    EXT(97),    EXT(107) },
  { VK_F5,        EXT(63),    EXT(88),    EXT(98),    EXT(108) },
  { VK_F6,        EXT(64),    EXT(89),    EXT(99),    EXT(109) },
  { VK_F7,        EXT(65),    EXT(90),    EXT(100),   EXT(110) },
  { VK_F8,        EXT(66),    EXT(91),    EXT(101),   EXT(111) },
  { VK_F9,        EXT(67),    EXT(92),    EXT(102),   EXT(112) },
  { VK_F10,       EXT(68),    EXT(93),    EXT(103),   EXT(113) },
  { VK_F11,       EXT(133),   EXT(135),   EXT(137),   EXT(139) },
  { VK_F12,       EXT(134),   EXT(136),   EXT(138),   EXT(140) },
  { 0xdc,         '\\',       '|',        0x1c,       EXT(43)  },
  { 0xbf,         '/',        '?',        -1,         EXT(53)  },
  { 0xbd,         '-',        '_',        0x1f,       EXT(130) },
  { 0xbb,         '=',        '+',        -1,         EXT(131) },
  { 0xdb,         '[',        '{',        0x1b,       EXT(26)  },
  { 0xdd,         ']',        '}',        0x1d,       EXT(27)  },
  { 0xba,         ';',        ':',        -1,         EXT(39)  },
  { 0xde,         '\'',       '"',        -1,         EXT(40)  },
  { 0xbc,         ',',        '<',        -1,         EXT(51)  },
  { 0xbe,         '.',        '>',        -1,         EXT(52)  },
  { 0xc0,         '`',        '~',        -1,         EXT(41)  },

  { -1,           -1,         -1,         -1,         -1       }  // KONIEC
};

// Funkcja inicjuje parametry konsoli - należy
// ją wywołać na samym początku programu
//--------------------------------------------

void _cinit()
{
  _hcout = GetStdHandle(STD_OUTPUT_HANDLE);
  _hcin  = GetStdHandle(STD_INPUT_HANDLE);
  _txattr = 7; // Czarne tło i białe znaki
  clrscr();
}

// Funkcja konwertuje tekst ze standardu Windows 1250
// na standard konsoli znakowej Latin II.
//---------------------------------------------------
// s - tekst kodowany wg Windows 1250
//---------------------------------------------------
string _pl(string s)
{
    for(unsigned i = 0; i < s.length(); i++)
        switch(s[i])
        {
            case 'ą' : s[i] = 165; break;
            case 'ć' : s[i] = 134; break;
            case 'ę' : s[i] = 169; break;
            case 'ł' : s[i] = 136; break;
            case 'ń' : s[i] = 228; break;
            case 'ó' : s[i] = 162; break;
            case 'ś' : s[i] = 152; break;
            case 'ż' : s[i] = 190; break;
            case 'ź' : s[i] = 171; break;
            case 'Ą' : s[i] = 164; break;
            case 'Ć' : s[i] = 143; break;
            case 'Ę' : s[i] = 168; break;
            case 'Ł' : s[i] = 157; break;
            case 'Ń' : s[i] = 227; break;
            case 'Ó' : s[i] = 224; break;
            case 'Ś' : s[i] = 151; break;
            case 'Ż' : s[i] = 189; break;
            case 'Ź' : s[i] = 141; break;
        }
    return s;
}

// Funkcja wyświetla zadany parametrem tekst
// na środku podanego wiersza konsoli
//------------------------------------------
void center(int y, string s)
{
  gotoxy((80 - s.length()) / 2, y);
  cout << s;
}

// Funkcja czyści ekran konsoli.
//------------------------------
void clrscr()
{
   COORD cpos = { 0, 0 };
   DWORD cwrt;
   CONSOLE_SCREEN_BUFFER_INFO cinf;
   DWORD csize;

   if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return;
   csize = cinf.dwSize.X * cinf.dwSize.Y;
   if(!FillConsoleOutputCharacter(_hcout,' ',csize,cpos,&cwrt)) return;
   if(!FillConsoleOutputAttribute(_hcout,_txattr,csize,cpos,&cwrt)) return;
   SetConsoleCursorPosition(_hcout, cpos);
   SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja wyłącza kursor
//-----------------------
void cursoroff()
{
  CONSOLE_CURSOR_INFO ccinf;

  GetConsoleCursorInfo(_hcout,&ccinf);
  ccinf.bVisible = false;
  SetConsoleCursorInfo(_hcout,&ccinf);
}

// Funkcja włącza kursor
//-----------------------
void cursoron()
{
  CONSOLE_CURSOR_INFO ccinf;

  GetConsoleCursorInfo(_hcout,&ccinf);
  ccinf.bVisible = true;
  SetConsoleCursorInfo(_hcout,&ccinf);
}

// Funkcja wstrzymuje wykonanie na zadaną
// liczbę milisekund
//---------------------------------------
// msec - liczba milisekund
//---------------------------------------
void delay(int msec)
{
  unsigned t1 = GetTickCount();
  while((GetTickCount() - t1) < (unsigned)msec) ;
}

// Funkcja wypełnia zadany obszar okna konsoli
// podanym atrybutem. Pozycja kursora oraz znaki
// zawarte w obszarze nie są zmieniane.
//----------------------------------------------
// attr - atrybut do wypełnienia obszaru
// xb,yb - współrzędne lewego górnego narożnika
// xe,ye - współrzędne prawego dolnego narożnika
//----------------------------------------------
void fillrectattr(WORD attr, int xb, int yb, int xe, int ye)
{
  CONSOLE_SCREEN_BUFFER_INFO cinf;
  COORD pos;
  DWORD crd;

  if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return;
  if((xb >= cinf.dwSize.X) || (yb >= cinf.dwSize.Y) ||
     (xe < xb) || (ye < yb) || (xe < 0) || (ye < 0)) return; // poza oknem
  if(xb < 0) xb = 0;
  if(yb < 0) yb = 0;
  if(xe >= cinf.dwSize.X) xe = cinf.dwSize.X - 1;
  if(ye >= cinf.dwSize.Y) ye = cinf.dwSize.Y - 1;
  DWORD len = xe - xb + 1;
  pos.X = xb;
  for(int i = yb; i <= ye; i++)
  {
    pos.Y = i;
    FillConsoleOutputAttribute(_hcout,attr,len,pos,&crd);
  }
}

// Funkcja wypełnia zadany obszar okna konsoli
// podanym znakiem. Pozycja kursora oraz atrybuty
// zawarte w obszarze nie są zmieniane.
//-----------------------------------------------
// c - znak do wypełnienia obszaru
// xb,yb - współrzędne lewego górnego narożnika
// xe,ye - współrzędne prawego dolnego narożnika
//-----------------------------------------------
void fillrectch(TCHAR c, int xb, int yb, int xe, int ye)
{
  CONSOLE_SCREEN_BUFFER_INFO cinf;
  COORD pos;
  DWORD crd;

  if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return;
  if((xb >= cinf.dwSize.X) || (yb >= cinf.dwSize.Y) ||
     (xe < xb) || (ye < yb) || (xe < 0) || (ye < 0)) return; // poza oknem
  if(xb < 0) xb = 0;
  if(yb < 0) yb = 0;
  if(xe >= cinf.dwSize.X) xe = cinf.dwSize.X - 1;
  if(ye >= cinf.dwSize.Y) ye = cinf.dwSize.Y - 1;
  DWORD len = xe - xb + 1;
  pos.X = xb;
  for(int i = yb; i <= ye; i++)
  {
    pos.Y = i;
    FillConsoleOutputCharacter(_hcout,c,len,pos,&crd);
  }
}

// Funkcja wypełnia zadany obszar okna konsoli
// podanym znakiem i atrybutem. Pozycja kursora
// nie jest zmieniana.
//----------------------------------------------
// c - znak do wypełnienia
// attr - atrybut do wypełnienia obszaru
// xb,yb - współrzędne lewego górnego narożnika
// xe,ye - współrzędne prawego dolnego narożnika
//----------------------------------------------
void fillrect(TCHAR c, WORD attr, int xb, int yb, int xe, int ye)
{
  CONSOLE_SCREEN_BUFFER_INFO cinf;
  COORD pos;
  DWORD crd;

  if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return;
  if((xb >= cinf.dwSize.X) || (yb >= cinf.dwSize.Y) ||
     (xe < xb) || (ye < yb) || (xe < 0) || (ye < 0)) return; // poza oknem
  if(xb < 0) xb = 0;
  if(yb < 0) yb = 0;
  if(xe >= cinf.dwSize.X) xe = cinf.dwSize.X - 1;
  if(ye >= cinf.dwSize.Y) ye = cinf.dwSize.Y - 1;
  DWORD len = xe - xb + 1;
  pos.X = xb;
  for(int i = yb; i <= ye; i++)
  {
    pos.Y = i;
    FillConsoleOutputCharacter(_hcout,c,len,pos,&crd);
    FillConsoleOutputAttribute(_hcout,attr,len,pos,&crd);
  }
}

// Funkcja rysuje prostokątną ramkę
// type - określa typ ramki. Dozwolone typy, to:
//        FRAME_EMPTY,FRAME_SINGLE,FRAME_DOUBLE,
//        FRAME_SOLID, FRAME_SHADED
// attr - określa atrybut koloru dla ramki
// xb,yb - współrzędne lewego górnego wierzchołka
// xe,ye - współrzędne dolnego prawego wierzchołka
//------------------------------------------------
void frame(int type,int attr,int xb,int yb,int xe,int ye)
{
  TCHAR c;

  if((xb >= xe) || (yb >= ye)) return;
  switch(type) // lewy górny róg
  {
    case FRAME_EMPTY : c =  32; break;
    case FRAME_SINGLE: c = 218; break;
    case FRAME_DOUBLE: c = 201; break;
    case FRAME_SOLID : c = 219; break;
    case FRAME_SHADED: c = 177; break;
  }
  fillrect(c,attr,xb,yb,xb,yb);
  switch(type) // lewy dolny róg
  {
    case FRAME_SINGLE: c = 192; break;
    case FRAME_DOUBLE: c = 200; break;
  }
  fillrect(c,attr,xb,ye,xb,ye);
  switch(type) // prawy górny róg
  {
    case FRAME_SINGLE: c = 191; break;
    case FRAME_DOUBLE: c = 187; break;
  }
  fillrect(c,attr,xe,yb,xe,yb);
  switch(type) // prawy dolny róg
  {
    case FRAME_SINGLE: c = 217; break;
    case FRAME_DOUBLE: c = 188; break;
  }
  fillrect(c,attr,xe,ye,xe,ye);
  switch(type) // góra i dół
  {
    case FRAME_SINGLE: c = 196; break;
    case FRAME_DOUBLE: c = 205; break;
  }
  fillrect(c,attr,xb + 1,yb,xe - 1,yb);
  fillrect(c,attr,xb + 1,ye,xe - 1,ye);
  switch(type) // lewy i prawy
  {
    case FRAME_SINGLE: c = 179; break;
    case FRAME_DOUBLE: c = 186; break;
  }
  fillrect(c,attr,xb,yb + 1,xb,ye - 1);
  fillrect(c,attr,xe,yb + 1,xe,ye - 1);
}

// Funkcja rysuje prostokątną ramkę z wypełnieniem
// type - określa typ ramki. Dozwolone typy, to:
//   FRAME_EMPTY  - ramka zbudowana ze spacji
//   FRAME_SINGLE - ramka pojedyncza
//   FRAME_DOUBLE - ramka podwójna
//   FRAME_SOLID  - ramka wypełniona znakiem pełnym
//   FRAME_SHADED - ramka wypełniona znakiem cieniowanym
// attr - określa atrybut koloru dla ramki i tła
// xb,yb - współrzędne lewego górnego wierzchołka
// xe,ye - współrzędne dolnego prawego wierzchołka
//------------------------------------------------
void fillframe(int type,int attr,int xb,int yb,int xe,int ye)
{
  frame(type,attr,xb,yb,xe,ye);
  fillrect(' ',attr,xb+1,yb+1,xe-1,ye-1);
}

// Funkcja przełącza okno konsoli w tryb pełnoekranowy
// lub okienkowy. Pełny ekran ma 80 kolumn x 50 wierszy
// mode = true  - pełny ekran
// mode = false - okno
//-----------------------------------------------------
void fullscreen(bool mode)
{
  COORD dim;
  SetConsoleDisplayMode(_hcout, mode ? 1 : 2, &dim);
}

// Funkcja odczytuje atrybut z pozycji x,y ekranu konsoli
//-------------------------------------------------------
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//-------------------------------------------------------
int getattrxy(int x, int y)
{
  COORD pos = {(short)x,(short)y};
  WORD attr;
  DWORD crd;

  ReadConsoleOutputAttribute(_hcout,&attr,1,pos,&crd);
  return attr;
}

// Funkcja odczytuje kod klawisza z bufora konsoli. Jeśli bufor jest pusty, czeka na klawisz.
// Odczytany znak nie pojawia się na ekranie. Jeśli naciśnięto klawisz sterujący, to pierwsze
// wywołanie funkcji zawsze zwraca kod 0. Drugie wywołanie zwraca kod klawiaturowy danego
// klawisza sterującego.
//-------------------------------------------------------------------------------------------
int getch()
{
  INPUT_RECORD inp;
  DWORD nread;
  DWORD kbdmode;
  struct kbd *k;
  int keycode, state, c;

// Jeśli poprzednie wywołanie zwróciło rozszerzony kod 0,
// zwracamy kod klawiaturowy tego klawisza.

  if(_cextend != -1)
  {
    c = _cextend;
    _cextend = -1; // Resetujemy znacznik
    return c;      // Zwracamy rozszerzony kod klawiaturowy
  }

// Pobieramy tryb pracy konsoli, a następnie ustawiamy go w tryb binarny.
// Robimy to, aby zapobiec przetwarzaniu przez Windows klawiszy sterujących
// np. Ctrl-C lub Ctrl-S.

  if(!GetConsoleMode(_hcin,&kbdmode)) return -1;
  if(!SetConsoleMode(_hcin,0))        return -1;

// Pobieramy zdarzenia klawiatury, aż napotkamy właściwe

  for (;;)
  {
    if(!ReadConsoleInput(_hcin, &inp, 1, &nread))
    {
      c = -1; break;
    }
    else if((inp.EventType == KEY_EVENT) && inp.Event.KeyEvent.bKeyDown)
    {
      keycode = inp.Event.KeyEvent.wVirtualKeyCode;
      state   = inp.Event.KeyEvent.dwControlKeyState;
      if((state & NUMLOCK_ON) && (keycode == VK_DELETE)) keycode = VK_DECIMAL;

// Poszukujemy wirtualnego kodu klawisza w tablicy. Ignorujemy
// nierozpoznane klawisze

      for(k = &kbdtab[0]; keycode != k->keycode && k->keycode != -1; k++) ;
      if(k->keycode == -1) continue; // wartość nieobecna w tablicy

// Sprawdzamy stan klawiszy sterujących. ALT posiada najwyższy priorytet
// następnie Ctrl i Shift. W zależności od stanu tych klawiszy
// wybieramy odpowiednią pozycję w tablicy

      if(state & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))        c = k->alt;
      else if(state & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) c = k->ctrl;
      else if(state & SHIFT_PRESSED)                            c = k->shift;
      else
      {

// Jeśli jest to klawisz znakowy, wykorzystujemy kod ASCII dostarczony
// przez Windows i uwzględniamy stan CapsLock.

        if(keycode >= 'A' && keycode <= 'Z')
          c = inp.Event.KeyEvent.uChar.AsciiChar;
        else
          c = k->normal;
      }
      if(c == -1) continue; // brak odpowiednika BIOS

// Jeśli jest to klawisz rozszerzony, zapamiętujemy jego kod
// i zwracamy 0.  Przy następnym wywołaniu zostanie zwrócona
// wartość klawisza.

      if(ISEXT(c))
      {
        _cextend = EXTVAL(c);
        c = 0;
      }
      break;
   }
  }

// Przywracamy normalny tryb pracy konsoli

  if(!SetConsoleMode(_hcin,kbdmode)) return -1;
  return c;
}

// Funkcja odczytuje znak z pozycji x,y ekranu konsoli
//----------------------------------------------------
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//----------------------------------------------------
char getchxy(int x, int y)
{
  COORD pos = {(short)x,(short)y};
  TCHAR c;
  DWORD crd;

  ReadConsoleOutputCharacter(_hcout,&c,1,pos,&crd);
  return c;
}

// Funkcja tworzy bufor na treść okna konsoli.
// Następnie umieszcza w tym buforze zawartość
// prostokątnego obszaru konsoli i zwraca
// wskazanie do bufora.
// xb,yb - współrzędne lewego górnego rogu
// xe,ye - współrzędna prawego dolnego rogu
//--------------------------------------------
WORD * getrect(int xb, int yb, int xe, int ye)
{
  CONSOLE_SCREEN_BUFFER_INFO cinf;
  COORD pos;
  DWORD crd;

  if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return NULL;
  if((xb >= cinf.dwSize.X) || (yb >= cinf.dwSize.Y) ||
     (xe < xb) || (ye < yb) || (xe < 0) || (ye < 0)) return NULL; // poza oknem
  if(xb < 0) xb = 0;
  if(yb < 0) yb = 0;
  if(xe >= cinf.dwSize.X) xe = cinf.dwSize.X - 1;
  if(ye >= cinf.dwSize.Y) ye = cinf.dwSize.Y - 1;
  DWORD len_x = xe - xb + 1;
  WORD * buf = new WORD[4 + 2 * len_x * (ye - yb + 1)];
  if(buf)
  {
    buf[0] = xb; buf[1] = yb; buf[2] = xe; buf[3] = ye; // współrzędne obszaru
    int j = 0;
    for(int i = yb; i <= ye; i++)
    {
      pos.X = xb; pos.Y = i;
      ReadConsoleOutputCharacter(_hcout,(CHAR *)(buf+4+(j++)*len_x),len_x,pos,&crd);
      ReadConsoleOutputAttribute(_hcout,buf+4+(j++)*len_x,len_x,pos,&crd);
    }
  }
  return buf;
}

// Funkcja umieszcza kursor na zadanej pozycji
//--------------------------------------------
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//--------------------------------------------
void gotoxy(int x, int y)
{
  COORD cpos = {(short)x,(short)y};
  SetConsoleCursorPosition(_hcout, cpos);
}

// Funkcja rozjaśnia kolor znaków
//-------------------------------
void highvideo()
{
  _txattr = _txattr | 0x8;
  SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja sprawdza, czy użytkownik nacisnął jakiś
// klawisz na klawiaturze. Jeśli tak, zwraca true.
//------------------------------------------------
bool kbhit()
{
  DWORD en, enr; // liczba zdarzeń oraz liczba odczytanych zdarzeń

  GetNumberOfConsoleInputEvents(_hcin, &en);
  INPUT_RECORD * ir = new INPUT_RECORD[en];  // przydzielamy pamięć
  PeekConsoleInput(_hcin, ir, en, &enr);     // odczytujemy zdarzenia

  for(DWORD i = 0; i < enr; i++)               // przeglądamy zdarzenia
  {
    if(ir[i].EventType & KEY_EVENT &&
       ir[i].Event.KeyEvent.bKeyDown)        // jeśli zdarzenie klawisza!
    {                                        // ale nie kontrolnego!
      if(ir[i].Event.KeyEvent.wVirtualKeyCode != VK_CONTROL &&
         ir[i].Event.KeyEvent.wVirtualKeyCode != VK_MENU &&
         ir[i].Event.KeyEvent.wVirtualKeyCode != VK_SHIFT)
      {
        delete ir; return true;              // klawisz w buforze konsoli
      }
    }
  }
  delete ir; return false;                   // bufor konsoli jest pusty
}

// Funkcja przyciemnia kolor znaków
//---------------------------------
void lowvideo()
{
  _txattr = _txattr & 0xf7;
  SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja zapisuje podany atrybut na pozycji x,y.
// Pozycja kursora i znak na tej pozycji nie są zmieniane
//-------------------------------------------------------
// attr - atrybut koloru
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//-------------------------------------------------------
void putattrxy(WORD attr, int x, int y)
{
  COORD pos = {(short)x,(short)y};
  DWORD cwrt;

  WriteConsoleOutputAttribute(_hcout,&attr,1,pos,&cwrt);
}

// Funkcja zapisuje podany znak na pozycji x,y.
// Pozycja kursora i atrybut pozycji nie są zmieniane.
//----------------------------------------------------
// c - znak ASCII do zapisu
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//----------------------------------------------------
void putchxy(TCHAR c, int x, int y)
{
  COORD pos = {(short)x,(short)y};
  DWORD cwrt;

  WriteConsoleOutputCharacter(_hcout,&c,1,pos,&cwrt);
}

// Funkcja odtwarza prostokątny obszar ekranu
// zapamiętany w buforze przez getrect(). Bufor
// jest zwalniany do puli pamięci systemu.
// buf - wskaźnik bufora z treścią obszaru
//---------------------------------------------
void putrect(WORD * buf)
{
  COORD pos;
  DWORD crd;

  if(!buf) return; // na wypadek, gdy bufor jest pusty!
  DWORD len_x = buf[2] - buf[0] + 1;
  int j = 0;
  for(int i = buf[1]; i <= buf[3]; i++)
  {
    pos.X = buf[0]; pos.Y = i;
    WriteConsoleOutputCharacter(_hcout,(CHAR *)(buf+4+(j++)*len_x),len_x,pos,&crd);
    WriteConsoleOutputAttribute(_hcout,buf+4+(j++)*len_x,len_x,pos,&crd);
  }
  delete buf;
}

// Funkcja zapisuje podany znak i atrybut na pozycji x,y.
// Pozycja kursora pozycji nie jest zmieniana.
//-------------------------------------------------------
// c - znak ASCII do zapisu
// attr - atrybut koloru
// x - pozycja w poziomie (0..79)
// y - pozycja w pionie   (0..49)
//-------------------------------------------------------
void putxy(TCHAR c, WORD attr, int x, int y)
{
  COORD pos = {(short)x,(short)y};
  DWORD cwrt;

  WriteConsoleOutputCharacter(_hcout,&c,1,pos,&cwrt);
  WriteConsoleOutputAttribute(_hcout,&attr,1,pos,&cwrt);
}

// Funkcja przesuwa zawartość prostokątnego obszaru
// w wyznaczonym kierunku o zadaną liczbę pozycji.
// Powstały pusty obszar wypełniony zostaje spacjami
// w aktualnym kolorze tła.
//------------------------------------------------------------------------
// dir - kierunek przesuwu okna. Dozwolone są następujące kierunki:
//   SCROLL_UP    - przesuw w górę
//   SCROLL_RIGHT - przesuw w prawo
//   SCROLL_DOWN  - przesuw w dół
//   SCROLL_LEFT  - przesuw w lewo
// howfar - określa liczbę kolumn lub wierszy, o które będzie przesunięcie
// xb,yb - współrzędna lewego górnego wierzchołka
// xe,ye - współrzędna prawego dolnego wierzchołka
//------------------------------------------------------------------------
void scrollrect(int dir, unsigned howfar, int xb, int yb, int xe, int ye)
{
  SMALL_RECT r,cr;
  COORD dest;
  CONSOLE_SCREEN_BUFFER_INFO cinf;

  if(!GetConsoleScreenBufferInfo(_hcout, &cinf)) return;
  if((xb >= cinf.dwSize.X) || (yb >= cinf.dwSize.Y) || (dir > 3) || !howfar ||
     (xe < xb) || (ye < yb) || (xe < 0) || (ye < 0)) return; // poza oknem
  if(xb < 0) xb = 0;
  if(yb < 0) yb = 0;
  if(xe >= cinf.dwSize.X) xe = cinf.dwSize.X - 1;
  if(ye >= cinf.dwSize.Y) ye = cinf.dwSize.Y - 1;
  dest.X = r.Left = cr.Left  = xb;
  dest.Y = r.Top  = cr.Top   = yb;
  r.Right  = cr.Right  = xe;
  r.Bottom = cr.Bottom = ye;
  switch(dir)
  {
    case SCROLL_UP    : r.Top    += howfar; break;
    case SCROLL_RIGHT : r.Right  -= howfar; dest.X += howfar; break;
    case SCROLL_DOWN  : r.Bottom -= howfar; dest.Y += howfar; break;
    case SCROLL_LEFT  : r.Left   += howfar; break;
  }
  CHAR_INFO chinf = {{' '},_txattr};
  ScrollConsoleScreenBuffer(_hcout,&r,&cr,dest,&chinf);
}

// Funkcja ustawia atrybut koloru
//-------------------------------
// attr - nowy atrybut
//-------------------------------
void textattr(int attr)
{
  _txattr = attr & 0xff;
  SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja ustawia kolor tła tekstu
//---------------------------------
// attr - kod koloru tekstu
//---------------------------------
void textbackground(int attr)
{
  _txattr = (_txattr & 0xf) | ((attr & 0xf) << 4);
  SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja ustawia kolor tekstu i tła
//--------------------------------------------
// attr - kod atrybutu dla koloru tekstu i tła
//--------------------------------------------
void textcolor(int attr)
{
  _txattr = (_txattr & 0xf0) | (attr & 0xf);
  SetConsoleTextAttribute(_hcout,_txattr);
}

// Funkcja odczytuje bieżącą pozycję x kursora
//--------------------------------------------
int wherex()
{
  CONSOLE_SCREEN_BUFFER_INFO sinf;

  GetConsoleScreenBufferInfo(_hcout,&sinf);
  return sinf.dwCursorPosition.X;
}

// Funkcja odczytuje bieżącą pozycję y kursora
//--------------------------------------------
int wherey()
{
  CONSOLE_SCREEN_BUFFER_INFO sinf;

  GetConsoleScreenBufferInfo(_hcout,&sinf);
  return sinf.dwCursorPosition.Y;
}