nedoPC.org

// MY Graphics format. Shabarshin A.A.   13.01.1995
const char copyright[]=
"\r\n  -=MY Graphics format=-  1995, UPI-Ekaterinburg, Shabarshin A.\r\n\r\n";
#ifndef __STDIO_H
#include <stdio.h>
#endif
#ifndef __STDLIB_H
#include <stdlib.h>
#endif
#ifndef __STRING_H
#include <string.h>
#endif
#ifndef __DOS_H
#include <dos.h>
#endif
#ifndef __GRAPHICS_H
#include <graphics.h>
#endif
#ifndef __SVGA_H
#include "svga.h"
#endif
#ifndef __MYG_H
#define __MYG_H

int _EGA=0;

#define MYG_EGA  1
#define MYG_VGA  2
#define MYG_SVGA 3

#define MYG_PATH 64

class MYG
{int x0,y0,
     col,row,
     xc,yc,
     koef,
     xt,yt,
     kadr,
     ver,
     disk,
     mkol,
     page_sw,
     page_a,
     page_v,
     spal;
 float k;
 FILE *f0;
 long tek,tend;
 char **im;
 void LineGor(int x1,int x2,int y);
 void LineVer(int y1,int y2,int x);
 void Point(int x,int y){PutP(x,y,GetP(x0+xc-(xc-x)/k,y0+yc-(yc-y)/k));};
 void SetBegin(){xt=x0;yt=y0;};
 int GetColor(){int c=GetP(xt,yt);
                if(++xt==x0+col)
                {  xt=x0;
                   int ytt=y0+row;
                   if(yt==ytt) {c=-999;yt--;}
                   if(++yt==ytt) xt=x0+col-1;
                }
                return c;
                };
 int PutColor(int c){int cc=0;
                PutP(xt,yt,c);
                if(++xt==x0+col)
                {  xt=x0;
                   int ytt=y0+row;
                   if(yt==ytt) {cc=-999;yt--;}
                   if(++yt==ytt) xt=x0+col-1;
                }
                return cc;
                };
 void PutLine(int,int);
 void PutP(int,int,int);
 int GetP(int x,int y){ if(koef){x*=koef;y*=koef;}
                        return getpixel(x,y);};
 void Seq(int x,int y,int n);
 void Arc(int x,int y,long n);
 int Mgetc(void){return disk?getc(f0):GetM(tek++);};
 void SetM(long l,char c){im[l>>15][l&0x7FFF]=c;};
 int  GetM(long l){return im[l>>15][l&0x7FFF];};
 void AskVer(int v){ver=v;if(v>2)Error(0);}
 public:
 char ct,ctt;
 Palette256 *dac256;
 MYG(int,int,int,int,int);
 MYG(int x,int y,char f[MYG_PATH],int k0,int pgp);
 MYG(char f[MYG_PATH]);
 ~MYG();
 void Error(int);
 int ComeOn(int,int,double);
 void SetKoef(int k0){koef=k0==1?0:k0;};
 int Save(char f[MYG_PATH]);
 int Append(char f[MYG_PATH]);
 int Show(int,int,int);
 int GetShot(void) {return kadr;};
 int GetCol(void) {return col;};
 int GetRow(void) {return row;};
 void Shot(void);
 void PageSwitch(int s){page_sw=s;};
 void InitG(void);
 int GetVer(void){return ver;}
 void SetStandardPalette(int);
 int GetStandardPalette(void){return dac256->GetStandardPalette();};
};

void MYG::LineGor(int x1,int x2,int y)
{for(int xx=x1;xx<=x2;xx++) Point(xx,y);}

void MYG::LineVer(int y1,int y2,int x)
{for(int yy=y1;yy<=y2;yy++) Point(x,yy);}

void MYG::Error(int e)
{  closegraph();
   printf("ОШИБКА : ");
   switch(e)
   {case 0:printf("Некоppектная веpсия пакета MYG !");break;
    case 1:printf("Некоppектно составленный MYG-файл !");break;
    case 2:printf("Неизвестная команда в MYG-файле !");break;
    case 3:printf("Не может откpыть MYG-файл !");break;
    case 4:printf("Несоответствие кадpа MYG-файлy !");break;
    case 5:printf("Ошибка MYG-системы !!!");break;

   }
   sound(1000);
   delay(250);
   nosound();
   exit(1);
}


MYG::MYG(int x,int y,int dx,int dy,int v=1)
{ x0=x;y0=y;disk=1;
  spal=1;
  AskVer(v);
  page_sw=0;
  col=dx;row=dy;
  koef=0;kadr=0;
  ct=ctt=0;mkol=0;
  InitG();
}


MYG::MYG(char f[MYG_PATH])
{ disk=0;
  page_sw=0;
  koef=0;kadr=0;
  spal=1;
  ct=ctt=0;tek=0L;
  char f00[MYG_PATH];
  strcpy(f00,f);
  strcat(f00,".myg");
  f0=fopen(f00,"rb");
  if(f0==NULL) Error(3);
  fseek(f0,0L,SEEK_END);
  tend=ftell(f0);
  fseek(f0,0L,SEEK_SET);
  AskVer(getc(f0));
  unsigned int i32=32768;
  mkol=(tend+1)/i32+1;
  im=new char*[mkol];
  long ss=tend+1;
  int iii=0;
  while(ss>=i32)
  {  im[iii++]=new char[i32];
     ss-=i32;
  }
  im[iii++]=new char[ss+1];
  while(iii<mkol) im[iii++]=NULL;
  fseek(f0,0L,SEEK_SET);
  for(int i=0;i<mkol;i++) fread(im[i],1,i32,f0);
  fclose(f0);
  InitG();
}


MYG::MYG(int x,int y,char f[MYG_PATH],int k0=0,int pgp=0)
{ disk=1;mkol=0;
  ct=ctt=0;kadr=0;
  spal=1;
  char f00[MYG_PATH];
  strcpy(f00,f);
  strcat(f00,".myg");
  f0=fopen(f00,"rb");
  if(f0==NULL) Error(3);
  AskVer(fgetc(f0));
  page_sw=(ver==1)?pgp:0;
  fseek(f0,0L,SEEK_SET);
  InitG();
  Show(x,y,k0);
  fclose(f0);
}


void MYG::InitG(void)
{ dac256=NULL;
  switch(ver)
  {  case 1: if(!_EGA)
             {_EGA=1;
             #ifndef GRAPH_BGI
             registerbgidriver(EGAVGA_driver);
             #endif
             int gd=EGA,gm=EGAHI;
             initgraph(&gd,&gm,"");
             }
             break;
     case 2: dac256=new Palette256(1);
             break;
  }
}


int MYG::Show(int x,int y,int k0=0)
{ char c1,c2,com;
  kadr=0;
  page_a=0;
  page_v=0;
  x0=x;y0=y;koef=k0;
  tek=0;
  int kol,ii,xi,yi;
  long siz;
  Mgetc();
  col=Mgetc()+256*Mgetc();
  row=Mgetc()+256*Mgetc();
  com=Mgetc();
  while(com!=0xFF)
  { switch(com)
    { case 0x00:// Заполнение стpоки по точкам
      case 0x01:
      case 0x02:// Наpисовать стpоку текущим цветом
      case 0x03:break;
      case 0x04:// Кадp в сжатом фоpмате
         siz=row;siz*=col;
         Arc(x0,y0,siz);
         //if(Mgetc()!=0xFC) Error(1);
         break;
      case 0x05:// Копиpование стpоки из пpедыдущей
      case 0x06:
      case 0x07:// Установка стандартной палитры из SVGA.H
         if(ver==1) Error(1);
         spal=Mgetc();
         dac256->SetStandardPalette(spal);
         break;
      case 0x0F:// Пустая команда
         break;
      // Стpока в сжатом фоpмате
      case 0x30: xi=Mgetc();yi=Mgetc();
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      case 0x31: xi=Mgetc();yi=Mgetc()+256;
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      case 0x32: xi=Mgetc()+256;yi=Mgetc();
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      case 0x33: xi=Mgetc()+256;yi=Mgetc()+256;
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      case 0x34: xi=Mgetc()+512;yi=Mgetc();
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      case 0x35: xi=Mgetc()+512;yi=Mgetc()+256;
                 Arc(xi,yi,Mgetc()+256*Mgetc());break;
      // Установка текущего цвета
      case 0xC0: ct=0;ctt=0;break;
      case 0xC1: ct=1;ctt=0x11;break;
      case 0xC2: ct=2;ctt=0x22;break;
      case 0xC3: ct=3;ctt=0x33;break;
      case 0xC4: ct=4;ctt=0x44;break;
      case 0xC5: ct=5;ctt=0x55;break;
      case 0xC6: ct=6;ctt=0x66;break;
      case 0xC7: ct=7;ctt=0x77;break;
      case 0xC8: ct=8;ctt=0x88;break;
      case 0xC9: ct=9;ctt=0x99;break;
      case 0xCA: ct=10;ctt=0xAA;break;
      case 0xCB: ct=11;ctt=0xBB;break;
      case 0xCC: ct=12;ctt=0xCC;break;
      case 0xCD: ct=13;ctt=0xDD;break;
      case 0xCE: ct=14;ctt=0xEE;break;
      case 0xCF: ct=15;ctt=0xFF;break;

      case 0xFC:// Маpкеp кадpа
         kadr++;
         #ifdef SHOT
            Shot();
         #endif
         if(page_sw)
         {  if(page_a)
            {  page_a=0;page_v=1;}
            else
            {  page_a=1;page_v=0;}
            setactivepage(page_a);
            setvisualpage(page_v);
         }
         break;
      // Задеpжки
      case 0xFD: delay(1000);break;
      case 0xFE: delay(Mgetc()+256*Mgetc());break;
      default:Error(2);
    }
    com=Mgetc();
  }
  return 1;
}


void MYG::Arc(int x,int y,long n)
{        char c,c1,c2;
         if(ver==2)ctt=1;
         int kol;
         long ss=0;
         xt=x;yt=y;
         while(ss<n)
         {  c=Mgetc();
            if(c==ctt)
            {  switch(ver)
               { case 1:
                   c1=Mgetc();
                   c2=Mgetc();
                   c=(c1&0xF0)>>4;
                   kol=(c1&0x0F)<<8|c2;
                   break;
                 case 2:
                   c=Mgetc();
                   kol=Mgetc();
                   break;
               }
               ss+=kol;
               PutLine(kol,c);
            }
            else
            {  switch(ver)
               { case 1:
                   ss++;ss++;
                   PutColor(c/16);
                   if(ss<=n) PutColor(c%16);
                   break;
                 case 2:
                   ss++;
                   PutColor(c);
                   break;
               }
            }
         }
}


MYG::~MYG()
{
if(!mkol) {for(int i=0;i<mkol;i++) delete im[i];};
if(!disk) delete im;
if(ver==2) delete dac256;
}


int MYG::ComeOn(int x,int y,double k0)
{ k=k0;xc=x+x0;yc=y+y0;// Вблизи точки пpиближения возникают искажения !
  ct=ctt=0;
  float xb,yb,xl,yl;
  float sxl,sxr,syu,syd;
  xb=x0;yb=y0;
  xl=x0+col-1;
  yl=y0+row-1;
  int x1,y1,x2,y2;
  float g=640;
  x1=xc-xb;if(x1<g) g=x1;
  y1=yc-yb;if(y1<g) g=y1;
  x2=xl-xc;if(x2<g) g=x2;
  y2=yl-yc;if(y2<g) g=y2;
  sxl=x1/g;syu=y1/g;
  sxr=x2/g;syd=y2/g;
  int x00;
  for(int g0=0;g0<g;g0++)
  {   x00=xb;xb+=sxl;
      while(x00<xb) LineVer(yb,yl,x00++);
      x00=xl;xl-=sxr;
      while(x00>xl) LineVer(yb,yl,x00--);
      x00=yb;yb+=syu;
      while(x00<yb) LineGor(xb,xl,x00++);
      x00=yl;yl-=syd;
      while(x00>yl) LineGor(xb,xl,x00--);
  }
  return 1;
}



int MYG::Save(char f[MYG_PATH])
{
char f00[MYG_PATH];
strcpy(f00,f);
strcat(f00,".myg");
f0=fopen(f00,"wb");
if(f0==NULL) Error(3);
fputc(ver,f0);
fputc(col%256,f0);
fputc(col/256,f0);
fputc(row%256,f0);
fputc(row/256,f0);
SetBegin();
int kol,i;
int c0,c1,c,cc1,cc2,cc3,co;
int cm[16];
c0=0;
switch(ver)
{case 1:
  for(i=0;i<16;i++) cm[i]=0;
  while((c=GetColor())!=-999)
  { if(c0!=c){ c0=c;
               if(kol>1&&kol<6) cm[c]++;
               kol=0;
             }
    else {if(kol++>=4096)
          {kol=0;
           c0=-1;
          }
         }
  }
  kol=cm[0];c0=0;
  for(i=0;i<16;i++){if(cm[i]<kol) {kol=cm[i];c0=i;}}
  ct=c0;ctt=ct+ct*16;c0=0xC0|ct;
  fputc(c0,f0);
  break;
 case 2:
  ctt=0x01;
  fputc(7,f0);
  fputc(spal,f0);
  break;
}
fputc(4,f0);
SetBegin();
c1=GetColor();c0=GetColor();
switch(ver)
{ case 1:
while(c1!=-999&&c0!=-999)
{  if(c0!=c1){c=c1*16+c0;
              fputc(c,f0);
              c1=GetColor();
              c0=GetColor();
             }
   else{      cc1=c1*16+c0;c=c0;
              c1=GetColor();c0=GetColor();
              cc2=c1*16+c0;
              if(c1==c&&c0==c)
              {  c1=GetColor();c0=GetColor();
                 cc3=c1*16+c0;
                 if(c1==c&&c0==c)
                 {  kol=5;while(c1==c&&c1!=-999)
                          {  c1=GetColor();
                             kol++;
                          }
                    while(kol>=4096)
                    {  fputc(ctt,f0);
                       co=c*16+15;
                       fputc(co,f0);
                       fputc(0xFF,f0);
                       kol-=4095;
                    }
                    fputc(ctt,f0);
                    co=c*16+kol/256;
                    fputc(co,f0);
                    fputc(kol%256,f0);
                    c0=GetColor();
                 }
                 else
                 {if(cc1==ctt&&cc2==ctt)
                    {fputc(ctt,f0);fputc(ct*16,f0);fputc(4,f0);}
                  else
                    {
                    if(cc1!=ctt) fputc(cc1,f0);
                    else{fputc(ctt,f0);fputc(ct*16,f0);fputc(2,f0);}
                    if(cc2!=ctt) fputc(cc2,f0);
                    else{fputc(ctt,f0);fputc(ct*16,f0);fputc(2,f0);}
                    }
                    if(cc3!=ctt) fputc(cc3,f0);
                    else{fputc(ctt,f0);fputc(ct*16,f0);fputc(2,f0);}
                    c1=GetColor();c0=GetColor();
                 }
              }
              else
              {  if(cc1!=ctt) fputc(cc1,f0);
                 else{fputc(ctt,f0);fputc(ct*16,f0);fputc(2,f0);}
                 if(cc2!=ctt) fputc(cc2,f0);
                 else{fputc(ctt,f0);fputc(ct*16,f0);fputc(2,f0);}
                 c1=GetColor();c0=GetColor();
              }
       }
}
if(c1!=-999) fputc(c1<<4,f0);
break;
case 2:if(c1==1)c1=2;if(c0==1)c0=2;
       while(c1!=-999&&c0!=-999)
       {if(c1!=c0){fputc(c1,f0);
                   c1=c0;
                   c0=GetColor();
                   if(c0==1)c0=2;
                  }
        else{      cc1=c1;c=c1;
                   c1=c0;
                   cc2=c0;
                   c0=GetColor();
                   if(c0==1)c0=2;
                   if(c0==c)
                   {  kol=2;while(c1==c&&c1!=-999)
                            {  c1=GetColor();
                               if(c1==1)c1=2;
                               kol++;
                            }
                      while(kol>=256)
                      {     fputc(ctt,f0);
                            fputc(c,f0);
                            fputc(0xFF,f0);
                            kol-=255;
                      }
                      fputc(ctt,f0);
                      fputc(c,f0);
                      fputc(kol,f0);
                      c0=GetColor();
                      if(c0==1)c0=2;
                   }
                   else
                   {  fputc(cc1,f0);
                      fputc(cc2,f0);
                      c1=c0;
                      c0=GetColor();
                      if(c0==1)c0=2;
                   }
            }
       }
}
fputc(0xFC,f0);
fputc(0xFF,f0);
fclose(f0);
return 1;
}



void MYG::PutP(int x,int y,int c){if(!koef) putpixel(x,y,c);
                              else{x*=koef;y*=koef;
                                   if(koef==2)
                                   {  putpixel(x,y,c);
                                      putpixel(x+1,y,c);
                                      putpixel(x+1,y+1,c);
                                      putpixel(x,y+1,c);
                                   }
                                   else
                                   {  putpixel(x,y,c);
                                      putpixel(x+1,y,c);
                                      putpixel(x+2,y,c);
                                      putpixel(x+2,y+1,c);
                                      putpixel(x+2,y+2,c);
                                      putpixel(x+1,y+2,c);
                                      putpixel(x,y+2,c);
                                      putpixel(x,y+1,c);
                                      putpixel(x+1,y+1,c);
                                   }
                              }};


void MYG::PutLine(int k,int c)
{ int d=x0+col-xt,p=1;
  setlinestyle(0,1,1);
  setcolor(c);
  while(p)
  { if(k<d)
    { if(!koef) line(xt,yt,xt+k-1,yt);
      else {int x00=xt*koef,y00=yt*koef,x01=x00+koef*k-1;
            if(koef==2) {
                         line(x00,y00,x01,y00);
                         line(x00,y00+1,x01,y00+1);
                        }
            else {       line(x00,y00,x01,y00);
                         line(x00,y00+1,x01,y00+1);
                         line(x00,y00+2,x01,y00+2);
                 }
           }
      xt+=k;
      p=0;
    }
    else
    { if(!koef) line(xt,yt,x0+col-1,yt);
      else {int x00=xt*koef,y00=yt*koef,x01=(x0+col)*koef-1;
            if(koef==2) {
                         line(x00,y00,x01,y00);
                         line(x00,y00+1,x01,y00+1);
                        }
            else {       line(x00,y00,x01,y00);
                         line(x00,y00+1,x01,y00+1);
                         line(x00,y00+2,x01,y00+2);
                 }
           }
      k-=d;yt++;xt=x0;d=col;
    }
  }
}



int MYG::Append(char f[MYG_PATH])
{
char f00[MYG_PATH];
strcpy(f00,f);
strcat(f00,".myg");
f0=fopen(f00,"r+b");
if(f0==NULL) Error(3);
if(ver<getc(f0)) Error(0);
if(col!=getc(f0)+256*getc(f0)) Error(4);
if(row!=getc(f0)+256*getc(f0)) Error(4);
fseek(f0,-1L,SEEK_END);
fputc(0x0F,f0);
fclose(f0);
char fff[16]="__myg__";
char *fn;
strcpy(fn,fff);
Save(fn);
FILE *f1;
strcat(fff,".myg");
f1=fopen(fff,"rb");
if(f1==NULL) Error(3);
f0=fopen(f00,"ab");
if(f0==NULL) Error(3);
fseek(f1,0L,SEEK_END);
long l=ftell(f1),li;
fseek(f1,5L,SEEK_SET);
for(li=6;li<=l;li++) fputc(getc(f1),f0);
fclose(f0);
fclose(f1);
return 1;
}

void MYG::SetStandardPalette(int p)
{ if(ver==1) Error(1);
  else
  {  spal=p;
     dac256->SetStandardPalette(p);
  }
}

#endif

// SVGA - 256 colors.  29.04.1995
// +SavePalette()    - 27.02.1997
// +LoadPalette()    - 27.02.1997

#ifndef __STDIO_H
#include <stdio.h>
#endif
#ifndef __STDLIB_H
#include <stdlib.h>
#endif
#ifndef __STRING_H
#include <string.h>
#endif
#ifndef __GRAPHICS_H
#include <graphics.h>
#endif
#ifndef __DOS_H
#include <dos.h>
#endif
#ifndef __SVGA_H
#define __SVGA_H

typedef unsigned char DacPalette256[256][3];
extern int far _Cdecl Svga256_fdriver[];

#define SVGA256_320x200  0
#define SVGA256_640x400  1
#define SVGA256_640x480  2
#define SVGA256_800x600  3
#define SVGA256_1024x768 4

#define PAL_GRAY 0
#define PAL_MAND 1
#define PAL_RGBW 2
#define PAL_RGST 3

int VIDEO=0;
int SVGA256=0;

int huge DetectVGA256()
{   int Vid=VIDEO;
    return Vid;
}

#ifndef _RGB_STRUCT
#define _RGB_STRUCT
struct RGB
{  unsigned char r,g,b;
   RGB(int r1,int g1,int b1){r=r1;g=g1;b=b1;};
   RGB(){r=63;g=63;b=63;};
};
#endif

struct Palette256
{    int stnd;
     char *VideoMem;
     DacPalette256 d;
     Palette256(){InitG();};
     Palette256(int m){InitG();SetStandardPalette(m);};
     void SetStandardPalette(int);
     int  GetStandardPalette(void){return stnd;};
     int LoadPalette(char* s);
     int SavePalette(char* s);
     void InitG(void){
        VideoMem=(char*)0xA0000000;
        if(!SVGA256)
        {SVGA256=1;
        installuserdriver("Svga256",DetectVGA256);
        #ifndef GRAPH_BGI
        registerfarbgidriver(Svga256_fdriver);
        #endif
        int gd=DETECT,gm;
        initgraph(&gd,&gm,"");
        }
     };
     ~Palette256(){
     //closegraph();SVGA256=0;
     };
     void SetPalette(int i,RGB col)
     {  d[i][0]=col.r;
        d[i][1]=col.g;
        d[i][2]=col.b;
     };
     void SetAllPalette(void) //{setvgapalette256(&d);};
     {  struct REGPACK reg;
        reg.r_ax = 0x1012;
        reg.r_bx = 0;
        reg.r_cx = 256;
        reg.r_es = FP_SEG(d);
        reg.r_dx = FP_OFF(d);
        intr(0x10,&reg);
     };
     RGB GetPalette(int i)
     {  RGB col;
        col.r=d[i][0];
        col.g=d[i][1];
        col.b=d[i][2];
        return col;
     };
     void GetAllPalette(void)  //{getvgapalette256(&d);};
     {  struct REGPACK reg;
        reg.r_ax = 0x1017;
        reg.r_bx = 0;
        reg.r_cx = 256;
        reg.r_es = FP_SEG(d);
        reg.r_dx = FP_OFF(d);
        intr(0x10,&reg);
     };
};

void Palette256::SetStandardPalette(int p)
{  stnd=p;
   int i,j,ii,jj,oo;
   unsigned char r,g,b;
   switch(p)
   {case PAL_GRAY:
         for(j=0;j<256;j++) SetPalette(j,RGB(j/4,j/4,j/4));
         SetAllPalette();
         break;
    case PAL_MAND:
         for(ii=0;ii<256;ii++)
         {   i=ii/64;oo=ii%64;
             switch(i)
             { case 0:r=oo;g=0;b=0;break;
               case 1:r=63-oo;g=oo;b=0;break;
               case 2:r=0;g=63-oo;b=oo;break;
               case 3:r=oo;g=oo;b=63;
             }
             SetPalette(ii,RGB(r,g,b));
         }
         SetAllPalette();
         break;
    case PAL_RGBW:
         for(ii=0;ii<256;ii++)
         {   i=ii/64;oo=ii%64;
             switch(i)
             { case 0:SetPalette(ii,RGB(oo,0,0));break;
               case 1:SetPalette(ii,RGB(0,oo,0));break;
               case 2:SetPalette(ii,RGB(0,0,oo));break;
               case 3:SetPalette(ii,RGB(oo,oo,oo));break;
             }
         }
         SetAllPalette();
         break;
    case PAL_RGST:
         for(i=0;i<16;i++){ ii=i<<2;oo=i<<4;
         for(j=0;j<16;j++){ jj=j<<2;
             SetPalette((oo|j),RGB(ii,jj,0));
         }}
         SetAllPalette();
         break;
   }
}

int Palette256::LoadPalette(char* s)
{  int b,g,r,i;
   char ss[100];
   strcpy(ss,s);
   strcat(ss,".pal");
   FILE *f=fopen(ss,"rb");
   for(i=0;i<256;i++)
   {
       r=fgetc(f);
       g=fgetc(f);
       b=fgetc(f);
       SetPalette(i,RGB(r,g,b));
   }
   SetAllPalette();
   fclose(f);
   return 1;
}

int Palette256::SavePalette(char* s)
{  int i;
   RGB p;
   char ss[100];
   strcpy(ss,s);
   strcat(ss,".pal");
   FILE *f=fopen(ss,"wb");
   GetAllPalette();
   for(i=0;i<256;i++)
   {
       p=GetPalette(i);
       fputc(p.r,f);
       fputc(p.g,f);
       fputc(p.b,f);
   }
   fclose(f);
   return 1;
}

Palette256 *dac256;
int OpenGraph256(int k)
{ int o=0;
  if(!SVGA256)
  {  dac256=new Palette256(k);
     o=1;
  }
  return o;
}


#endif