:) kto to ma pomysł na program?

#include <iostream>
#include <conio.h>
#include "ddtconsole.h"

int main()
{
    enum { nowalina = 1, powtorz = 2, gotoxy_ = 3, kolor = 4, fill = 5, obiekt_ = 6 };
    /* obrazek() generuje obrazek
                               ze znaków ASCI
                               znak=0 spacja
                               znak=1 wprowadza \n
                               znak=2 ilość powtórzeń kolejnej wartości obrazek[p+1];
                                      2,n,(kodASCI)                        
                               znak=3 dwie kolejne wartości z obrazek
                                      ustawia gotoxy(x,y) obrazek[]={3,x,y}
                               znak=4 ustawia kolor textcolor(1-15) 4,n,
                               znak=5 fill x1/y1->x2/y2 wypełnia dany obszar znakiem.
                                      5,x1,y1,x2,y2, (kodASCI)niestety tylko od
                                      lewego górnego do prawego dolnego
                                      kombinacje x1=x2 linia pionowa
                                      kombinacja y1=y2 linia pozioma
                                     
                               znak=6 wstawianie obiektu rozmiaru x/y z innej tablicy.
                               w miejscu x,y. 6,n(obiekt[n-1][]),x,y(dla gotoxy)
                               budowa obrazek[]={1-6 wyierane case ze swichta,... ...}
                               budowa obiekt[nr_obiektu][]={ob_x,ob_y(rozmiary obiektu},
                                                Kody ASCI,
                                                256-znak dodatkowy "przeźroczysty"}
                               do zrobienia:
                               znak=7,8,9,10... (rysowanie linii ukośnych, kółek itp
                                                 w marzeniach oczywiście.
                           
                            */
    int obrazek[] = { 4, 1, // kolor 1
        2, 80, 'A', // 80x'A'
        1, // "\n"
        4, 10, //kolor 10
        3, 10, 10, // goto 10,10
        'O', //drukuje znak "O"
        4, 8, //kolor 8
        5, 12, 10, 68, 20, 176, //rysuje prostokąt 12,12->68,20
        4, 10, //kolor 10
        6, 1, 13, 13,
        4, 12,
        6, 3, 60, 3,
        5, 20, 5, 20, 22, 48, // rysuje prostokąt o szerokości znaku
        // i długości 17 znaków
        49,
        4, 4, // '1'
        6, 0, 14, 12,
        4, 5,
        6, 1, 16, 18
    }
    ;
    int obiekt[ 4 ][ 103 ] = {
        { 5, 3, 201, 205, 205, 205, 187,
            186, 256, 256, 256, 186,
            200, 205, 205, 205, 188 },
        { 6, 6, 201, 205, 205, 205, 205, 187,
            186, 256, 256, 256, 'A', 186,
            186, 256, 256, 'A', 256, 186,
            186, 256, 'A', 256, 256, 186,
            186, 'A', 256, 256, 256, 186,
            200, 205, 205, 205, 205, 188 },
        { 3, 3, 'a', 'b', 'c',
            201, 201, 201,
            201, 201, 201 },
        { 5, 7, 219, 219, 219, 219, 219, 219, 0, 0, 0, 219, 219, 0, 0, 0, 219, 219, 0, 0, 0, 219, 219, 0, 0, 0, 219, 219, 0, 0, 0, 219, 219, 219, 219, 219, 219 }
    };
   
    int ilosc_powtorzen = 0;
    int znak = 0;
    using namespace ddt::console;
    using std::cout;
   
    for( int p = 0; p < 51; ++p )
    {
        znak = obrazek[ p ];
        int licznik = 2;
        switch( znak )
        {
        case nowalina:
            cout << "\n";
            break;
        case powtorz:
            for( int q = 0; q < obrazek[( p + 1 ) ]; ++q )
                 cout << char( obrazek[( p + 2 ) ] );
           
            p += 2;
            break;
        case gotoxy_:
            int x;
            int y;
            p++;
            x = obrazek[ p ];
            p++;
            y = obrazek[ p ];
            gotoxy( x, y );
            break;
        case kolor:
            p++;
            textcolor( obrazek[ p ] );
            break;
        case fill:
            int x1, x2, y1, y2;
            p++; x1 = obrazek[ p ]; p++; y1 = obrazek[ p ]; p++; x2 = obrazek[ p ]; p++; y2 = obrazek[ p ];
            gotoxy( x1, y1 );
            p++;
            int ny;
            ny = y1;
            int nx;
            nx = x1;
            for( int n = 0; n <=( y2 - y1 ); ++n )
            {
                for( int m = 0; m <=( x2 - x1 ); m++ )
                     cout << char( obrazek[ p ] );
               
                ny++;
                gotoxy( nx, ny );
            }
            break;
           
        case obiekt_:
            p++;
            int nr_obiektu;
            nr_obiektu = obrazek[ p ];
            p++;
            int poz_o_x = obrazek[ p ];
            p++;
            int poz_o_y = obrazek[ p ];
            int mx = poz_o_x;
            int my = poz_o_y;
            gotoxy( mx, my );
            int ob_x = obiekt[ nr_obiektu ][ 0 ];
            int ob_y = obiekt[ nr_obiektu ][ 1 ];
           
            for( int y = 0; y < ob_y; ++y )
            {
                gotoxy( mx, my + y );
                for( int x = licznik; x < ob_x + licznik; ++x )
                if( obiekt[ nr_obiektu ][ x ] == 256 )
                     gotoxy( wherex() + 1, my + y );
               
                else
                     cout << char( obiekt[ nr_obiektu ][ x ] );
               
                licznik += ob_x;
            }
           
            break;
        }
        if( znak != 0 && znak > 6 ) cout << char( obrazek[ p ] );
       
        if( znak == 0 ) cout << char( 0 );
       
    }
   
    getch();
    return( 0 );
}



}