и ако някои е жив да напишем няква игричка нека каже.
ето Ви една библиотека за да разберете че не се заяждам.
#include <io.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <bios.h>
#include <fcntl.h>
#include <memory.h>
#include <math.h>
#include <malloc.h>
#include <graph.h>
#define ROM_CHAR_SET_SEG 0xF000
#define ROM_CHAR_SET_OFF 0xFA6E
#define V  1
#define T  0
#define PALETTE_MASK 0x3c6
#define PALETTE_REGISTER 0x3c8
#define PALETTE_DATA 0x3c9
#define SCREEN_WIDTH (unsigned int) 320
#define SCREEN_HEIGHT (unsigned int) 200
#define SPRITE_WIDTH 49
#define SPRITE_HEIGHT 19
#define CHAR_WIDTH 8
#define CHAR_HEIGHT 8
#define MAX_SPRITE_FRAMES 24
#define SPRITE_DEAD 0
#define SPRITE_ALIVE 1
#define SPRITE_DYING 2
typedef struct RGB_color_typ
  {
    unsigned char red;
    unsigned char green;
    unsigned char blue;
  }RGB_color, *RGB_color_ptr;

typedef struct pcx_header_typ
  {
    char manufacturer;
    char version;
    char encoding;
    char bits_per_pixel;
    int x,y;
    int width,height;
    int horz_res;
    int vert_res;
    char ega_palette[48];
    char reserved;
    char num_color_planes;
    int bytes_per_line;
    int palette_type;
    char padding[58];
  }pcx_header, *pcx_header_ptr;

typedef struct Cheks_typ
  {
    int a;
    int b;
    int c;
    int d;
  }Cheks, *Cheks_ptr;

typedef struct pcx_picture_typ
  {
    pcx_header header;
    RGB_color palette [256];
    char far *buffer;

  } pcx_picture, *pcx_picture_ptr;

typedef struct sprite_typ
  {
  int x,y;
  int x_old,y_old;
  int width,height;
  int anim_clock;
  int anim_speed;
  int motion_speed;
  int motion_clock;
  char far *frames[MAX_SPRITE_FRAMES];
  int curr_frame;
  int num_frames;
  int state;
  char far *background;
  }sprite, *sprite_ptr;

void Set_Palette_Register(int index,RGB_color_ptr color);
void Plot_Pixel_Fast(int x,int y,unsigned char color);
void PCX_Init(pcx_picture *image);
void PCX_Delete(pcx_picture *image);
void PCX_Load(char *filename,pcx_picture_ptr image,int enable_palette);
void PCX_Show_Buffer(pcx_picture_ptr image);

unsigned char far *video_buffer = (char far *) 0xA0000000L;
unsigned char far *video_buffer_w = (char far *) 0xA0000000L;
unsigned char far *rom_char_set = (char far *) 0xF000FA6EL;
unsigned int far *clock = (unsigned int far *) 0x0000046C;
void Blit_Char(int xc,int yc,char c,int color)
    {
    int offset,x,y;
    unsigned char data;
    char far *work_char;
    unsigned char bit_mask = 0x80;

    work_char = rom_char_set + c *CHAR_HEIGHT;

    offset = (yc << + (yc << 6) + xc;
    for (y =0;y<CHAR_HEIGHT;y++)
       {
         bit_mask = 0x80;
           for(x=0;x<CHAR_WIDTH;x++)
            {
             if((*work_char & bit_mask))
               video_buffer[offset+x] = color;
                bit_mask = (bit_mask >> 1);
            }
         offset +=SCREEN_WIDTH;
         work_char++;
       }
    }

void Blit_String(int x,int y,int color,char *string)
    {
      int index;
      for (index = 0;string[index]!=0;index++)
         {
          Blit_Char(x+(index <<3),y,string[index],color);
         }
    }

void Delay(int t)
   {
    float x=1;
    while(t-->0)
    x=cos(x);
   }
void VGA_MODE(int mode)
    {
     if (mode == V)
        _asm
          {
            mov ah,0
            mov al,byte ptr 0x13
            int 10h
          }
     else
        _asm
          {
            mov ah,0
            mov al,byte ptr 0x03
            int 10h
          }
     }


void Set_Palette_Register(int index,RGB_color_ptr color)
   {
    _outp(PALETTE_MASK,0xff);
    _outp(PALETTE_REGISTER,index);
    _outp(PALETTE_DATA,color -> red);
    _outp(PALETTE_DATA,color -> green);
    _outp(PALETTE_DATA,color -> blue);
   }

void PCX_Init(pcx_picture_ptr image)
   {
   if(!(image->buffer = (char far *) _fmalloc(SCREEN_WIDTH*SCREEN_HEIGHT+1)))
     printf("\n Sorry the file is to B.I.G.!");
    }

void Plot_Pixel_Fast(int x,int y,unsigned char color)
   {
   video_buffer[((y<< +(y<<6))+x] = color;
   }

void PCX_Delete(pcx_picture_ptr image)
   {
    _ffree(image->buffer);

   }
void PCX_Load(char *filename,pcx_picture_ptr image,int enable_palette)
   {
    FILE *fp;
    int num_bytes,index;
    long count;
    unsigned char data;
    char far *temp_buffer;

       fp = fopen(filename,"rb");
       temp_buffer = (char far *)image;
       for (index =0;index<128;index++)
         {
           temp_buffer[index] = getc(fp);
         }

       count = 0;
       while (count <= SCREEN_WIDTH*SCREEN_HEIGHT)
          {
           data = getc(fp);

            if (data >=192 && data <= 255)
              {
                num_bytes = data - 192;
                data = getc(fp);
                 while(num_bytes --> 0 )
                   {
                    image ->buffer[count++] = data;
                   }
              }
            else
              {
                image ->buffer[count++] = data;
              }
           }

       fseek(fp,-768L,SEEK_END);
       for (index = 0;index<256;index++)
          {
            image->palette[index].red = (getc (fp) >>2);
            image->palette[index].green = (getc (fp) >>2);
            image->palette[index].blue = (getc (fp) >>2);
          }
       fclose(fp);
       if (enable_palette)
        {
          for (index = 0;index<256;index++)
           {
             Set_Palette_Register(index,(RGB_color_ptr)&image->palette[index]);
           }
        }
   }

void PCX_Show_Buffer(pcx_picture_ptr image)
   {
     _fmemcpy((char far *)video_buffer,
         (char far *)image->buffer,SCREEN_WIDTH*SCREEN_HEIGHT);
   }

Sprite_Init(sprite_ptr sprite,int x,int y,int ac,int as,int mc,int ms)
   {
      int index;

      sprite->x = x;
      sprite->y = y;
      sprite->x_old = x;
      sprite->y_old = y;
      sprite->width = SPRITE_WIDTH;
      sprite->height = SPRITE_HEIGHT;
      sprite->anim_clock = ac;
      sprite->anim_speed = as;
      sprite->motion_clock = mc;
      sprite->motion_speed = ms;
      sprite->curr_frame = 0;
      sprite->state   = SPRITE_DEAD;
      sprite->num_frames = 0;
      sprite->background = (char far *) _fmalloc(SPRITE_WIDTH*SPRITE_HEIGHT+1);
      for (index = 0;index<MAX_SPRITE_FRAMES;index++)
          sprite->frames[index] = NULL;
   }

void Sprite_Delete(sprite_ptr sprite)
   {
    int index;
    _ffree(sprite->background);
    for(index=0;index<MAX_SPRITE_FRAMES;index++)
      _ffree(sprite->frames[index]);
   }
void PCX_Grap_Bitmap(pcx_picture_ptr image,
          sprite_ptr sprite,
          int sprite_frame,
          int grab_x,int grab_y)

   {
   int x_off,y_off,x,y,index;
   char far *sprite_data;

   sprite->frames[sprite_frame] = (char far *)malloc(SPRITE_WIDTH*SPRITE_HEIGHT);
   sprite_data = sprite->frames[sprite_frame];
   x_off = (SPRITE_WIDTH+1) * grab_x +1;
   y_off = (SPRITE_HEIGHT+1) * grab_y +1;
  
  
   for (y=0;y<SPRITE_HEIGHT;y++)
      {
        for (x=0;x<SPRITE_WIDTH;x++)
         {
           sprite_data[y*SPRITE_WIDTH + x] = image->buffer[y_off + x_off + x];
         }
        y_off+=320;
      }
      sprite->num_frames++;
    
      

   }
void Behind_Sprite(sprite_ptr sprite)
   {

   char far *work_back;
   int work_offset=0,offset,y;
   work_back = sprite->background;
   offset = (sprite->y<< + (sprite->y<<6) + sprite->x;
   for (y = 0; y<SPRITE_HEIGHT;y++)
      {
       _fmemcpy((char far *)&work_back[work_offset],
           (char far *)&video_buffer[offset],
           SPRITE_WIDTH);

       offset +=SCREEN_WIDTH;
       work_offset +=SPRITE_WIDTH;
      }
   }

void Erase_Sprite(sprite_ptr sprite)
   {
    char far * work_back;
    int work_offset=0,offset,y;

    work_back = sprite->background;

    offset = (sprite->y_old << + (sprite->y_old << 6) + sprite->x_old;
    for(y=0;y<SPRITE_HEIGHT;y++)
     {
      _fmemcpy ((char far *)&video_buffer[offset],
      (char far *)&work_back[work_offset],
      SPRITE_WIDTH);
      offset +=SCREEN_WIDTH;
      work_offset +=SPRITE_WIDTH;
     }
   }
void Draw_Sprite(sprite_ptr sprite)
   {
    char far *work_sprite;
    int work_offset=0,offset,x,y;
    unsigned char data;

    work_sprite = sprite->frames[sprite->curr_frame];

    offset = (sprite->y << + (sprite->y << 6) + sprite-> x;
    for (y=0;y<SPRITE_HEIGHT;y++)
       {
         for (x=0;x<SPRITE_WIDTH;x++)
           {
            if((data=work_sprite[work_offset+x]))
            video_buffer[offset+x] = data;
           }

         offset +=SCREEN_WIDTH;
         work_offset += SPRITE_WIDTH;
       }
   }
unsigned char Get_Scan_Code(void)
     {
       _asm
         {
           mov ah,01h
           int 16h
           jz empty
           mov ah,00h
           int 16h
           mov al,ah
           xor ah,ah
           jmp done

           empty:
           xor ax,ax
           done:
          }
      }  
void Show_Double_Buffer(char far *buffer)
     {
      _asm
       {
         push ds
         les di,video_buffer
         lds si,buffer
         mov cx,320*200/2
         rep movsw
         pop ds
       }
     }

void Timer(int clicks)
     {
        unsigned int now;
        now = *clock;
        while(abs(*clock - now)<clicks){}
     }

Абе хора защо всичките сте такива настръхнали?
Това нали е форум споделям моето мнение.
И ако си мислите че като има много дистрибуции ще спре някои да го направи платено и да си поиска своето според мен много се лъжете.
Явно Всичките сте много враждебно настроени.
Ще поживеем ще видим........... кои крив кои прав

Nali jiveem v BG koi vi kara da plastate za Win.
I ako moje niakoi da mi obiasni s kakvo Linux e po shokar ot WIN?
Kakvo s komandata "ls" sas nad 70 switcha li? kakvo?
?