GAME/VIEW.C

   1 #include "glob.h"
   2 #include <string.h>
   3 #include <malloc.h>
   4 #include "vga.h"
   5 #include "memory.h"
   6 #include "files.h"
   7 #include "error.h"
   8 #include "view.h"
   9 #include "dots.h"
  10 #include "smoke.h"
  11 #include "weapons.h"
  12 #include "items.h"
  13 #include "switch.h"
  14 #include "fx.h"
  15 #include "player.h"
  16 #include "monster.h"
  17 #include "misc.h"
  18 #include "map.h"
  19
  20 #define ANIT 5
  21
  22 #define WD 200
  23 #define HT 98
  24 #define MAXX (FLDW*CELW-WD/2)
  25 #define MAXY (FLDH*CELH-HT/2)
  26
  27 extern map_block_t blk;
  28
  29 extern byte clrmap[256*12];
  30 void V_remap_rect(int,int,int,int,byte *);
  31
  32 byte w_horiz=ON;
  33 static void *horiz=NULL;
  34 int w_o,w_x,w_y,sky_type=1;
  35 void *walp[256];
  36 dword walf[256];
  37 int walh[256];
  38 byte walswp[256];
  39 byte walani[256];
  40 int anih[ANIT][5];
  41 byte anic[ANIT];
  42 byte fldb[FLDH][FLDW];
  43 byte fldf[FLDH][FLDW];
  44 byte fld[FLDH][FLDW];
  45
  46 extern int lt_time,lt_type,lt_side,lt_ypos;
  47 extern void *ltn[2][2];
  48
  49 static void getname(int n,char *s) {
  50   if(walh[n]==-1) {memset(s,0,8);return;}
  51   if(walh[n]==-2) {
  52     memcpy(s,"_WATER_",8);s[7]=(byte)walp[n]-1+'0';
  53     return;
  54   }
  55   F_getresname(s,walh[n]&0x7FFF);
  56 }
  57
  58 static short getani(char *n) {
  59   if(strnicmp(n,"WALL22_1",8)==0) return 1;
  60   if(strnicmp(n,"WALL58_1",8)==0) return 2;
  61   if(strnicmp(n,"W73A_1",8)==0) return 3;
  62   if(strnicmp(n,"RP2_1",8)==0) return 4;
  63   return 0;
  64 }
  65
  66 void W_savegame(int h) {
  67   char s[8];
  68   int i;
  69
  70   write(h,&sky_type,4);
  71   for(i=1;i<256;++i) {
  72     getname(i,s);write(h,s,8);
  73   }
  74   write(h,walf,sizeof(walf));
  75   write(h,walswp,sizeof(walswp));
  76   write(h,fldb,FLDW*FLDH);
  77   write(h,fld,FLDW*FLDH);
  78   write(h,fldf,FLDW*FLDH);
  79 }
  80
  81 void W_loadgame(int h) {
  82   char s[8];
  83   int i;
  84
  85   read(h,&sky_type,4);
  86   for(i=1;i<256;++i) {
  87     walani[i]=0;
  88     read(h,s,8);if(!s[0]) {walh[i]=-1;walp[i]=NULL;continue;}
  89     walani[i]=getani(s);
  90     if(memicmp(s,"_WATER_",7)==0) {
  91       walh[i]=-2;walp[i]=(void*)(s[7]-'0'+1);
  92     }else walp[i]=M_lock(walh[i]=F_getresid(s));
  93   }
  94   read(h,walf,sizeof(walf));
  95   for(i=1;i<256;++i) if(walf[i]&1) walh[i]|=0x8000;
  96   read(h,walswp,sizeof(walswp));
  97   read(h,fldb,FLDW*FLDH);
  98   read(h,fld,FLDW*FLDH);
  99   read(h,fldf,FLDW*FLDH);
 100   strcpy(s,"RSKY1");s[4]=sky_type+'0';
 101   M_unlock(horiz);
 102   horiz=M_lock(F_getresid(s));
 103 }
 104
 105 void W_adjust(void) {
 106   if(w_x<WD/2) w_x=WD/2;
 107   if(w_y<HT/2) w_y=HT/2;
 108   if(w_x>MAXX) w_x=MAXX;
 109   if(w_y>MAXY) w_y=MAXY;
 110 }
 111
 112 void W_draw(void) {
 113   W_adjust();
 114   V_setrect(0,WD,w_o+1,HT);
 115   if(w_horiz) {
 116     V_pic(127-(word)(w_x-WD/2)*56U/(word)(MAXX-WD/2),
 117           w_o+123-(word)(w_y-HT/2)*28U/(word)(MAXY-HT/2),horiz);
 118     if(sky_type==2) if(lt_time<0) {
 119       if(!lt_side) V_spr(0,w_o+lt_ypos,ltn[lt_type][(lt_time<-5)?0:1]);
 120       else V_spr2(WD-1,w_o+lt_ypos,ltn[lt_type][(lt_time<-5)?0:1]);
 121     }
 122   }else V_clr(0,WD,w_o+1,HT,0x97);
 123 /*  x=w_x-WD/2;y=w_y-HT/2;
 124   sx=x/CELW;xo=-(x%CELW)+1;
 125   sy=y/CELH;yo=-(y%CELH)+w_o+1;
 126 */
 127   Z_drawfld((byte *)fldb);
 128 /*  for(y=1-MAXTXH;y<HT/CELH+2;++y) if(y+sy>0 && y+sy<FLDH)
 129     for(x=1-MAXTXW;x<WD/CELW+2;++x) if(x+sx>0 && x+sx<FLDW)
 130     if((c=fldb[sy+y][sx+x])!=0) {
 131       if(!(p=M_lock(walh[c]))) ERR_fatal("W_draw: not enough memory");
 132       V_drawwall(x*CELW+xo,y*CELH+yo,wal[c].sx,wal[c].sy,wal[c].w*CELW,wal[c].h*CELH,p);
 133       M_unlock(walh[c]);
 134     }
 135 */
 136   DOT_draw();
 137   IT_draw();
 138   PL_draw(&pl1);
 139   if(_2pl) PL_draw(&pl2);
 140   MN_draw();
 141   WP_draw();
 142   SMK_draw();
 143   FX_draw();
 144   Z_drawfld((byte *)fldf);
 145   if(sky_type==2)
 146     if(lt_time==-4 || lt_time==-2)
 147       V_remap_rect(0,WD,w_o+1,HT,clrmap+256*11);
 148 }
 149
 150 void W_init(void) {
 151   int i,j;
 152   static char *anm[ANIT-1][5]={
 153     {"WALL22_1","WALL23_1","WALL23_2",NULL,NULL},
 154     {"WALL58_1","WALL58_2","WALL58_3",NULL,NULL},
 155     {"W73A_1","W73A_2",NULL,NULL,NULL},
 156     {"RP2_1","RP2_2","RP2_3","RP2_4",NULL}
 157   };
 158
 159   for(i=1;i<ANIT;++i) {
 160     for(j=0;anm[i-1][j];++j)
 161       anih[i][j]=F_getresid(anm[i-1][j]);
 162     for(;j<5;++j) anih[i][j]=-1;
 163   }
 164   memset(anic,0,sizeof(anic));
 165   DOT_init();
 166   SMK_init();
 167   FX_init();
 168   WP_init();
 169   IT_init();
 170   SW_init();
 171   PL_init();
 172   MN_init();
 173   M_unlock(horiz);
 174   horiz=M_lock(F_getresid("RSKY1"));
 175 }
 176
 177 void W_act(void) {
 178   int i,a;
 179
 180   if(g_time%3!=0) return;
 181   for(i=1;i<256;++i) if((a=walani[i])!=0) {
 182     if(anih[a][++anic[a]]==-1) anic[a]=0;
 183     walp[i]=M_lock(anih[a][anic[a]]);
 184   }
 185 }
 186
 187 static void unpack(void *buf,int len,void *obuf) {
 188   byte *p,*o;
 189   int l,n;
 190
 191   for(p=(byte*)buf,o=(byte*)obuf,l=len;l;++p,--l) if(*p==255) {
 192     n=*((word*)(++p));memset(o,*(p+=2),n);o+=n;l-=3;
 193   }else *(o++)=*p;
 194 }
 195
 196 int W_load(int h) {
 197   int i,j,k,g;
 198   static wall_t w;
 199   void *p,*buf;
 200
 201   switch(blk.t) {
 202         case MB_WALLNAMES:
 203           for(i=0;i<256;++i) {walh[i]=-1;walswp[i]=i;walani[i]=0;}
 204           for(i=1;i<256 && blk.sz>0;++i,blk.sz-=sizeof(w)) {
 205                 read(h,&w,sizeof(w));
 206                 if(memicmp(w.n,"_WATER_",7)==0)
 207                   {walp[i]=(void*)(w.n[7]-'0'+1);walh[i]=-2;continue;}
 208                 walp[i]=M_lock(walh[i]=F_getresid(w.n));
 209                 if(w.n[0]=='S' && w.n[1]=='W' && w.n[4]=='_') walswp[i]=0;
 210                 walf[i]=(w.t)?1:0;if(w.t) walh[i]|=0x8000;
 211                 if(memicmp(w.n,"VTRAP01",8)==0) walf[i]|=2;
 212                 walani[i]=getani(w.n);
 213           }
 214           for(j=i,i=1;i<256;++i) if(walswp[i]==0) {
 215                 if(j>=256) break;
 216                 F_getresname(w.n,walh[i]&0x7FFF);
 217                 w.n[5]^=1;
 218                 g=F_getresid(w.n)|(walh[i]&0x8000);
 219                 for(k=1;k<256;++k) if(walh[k]==g) break;
 220                 if(k>=256) {
 221                   walh[k=j++]=g;walp[k]=M_lock(g);
 222                   walf[k]=(g&0x8000)?1:0;
 223                 }
 224                 walswp[i]=k;walswp[k]=i;
 225           }
 226           return 1;
 227         case MB_BACK:  p=fldb;goto unp;
 228         case MB_WTYPE: p=fld;goto unp;
 229         case MB_FRONT: p=fldf;
 230         unp: switch(blk.st) {
 231             case 0: read(h,p,FLDW*FLDH);break;
 232             case 1:
 233               if(!(buf=malloc(blk.sz)))
 234                 ERR_fatal("Не хватает памяти");
 235               read(h,buf,blk.sz);
 236               unpack(buf,blk.sz,p);free(buf);break;
 237             default: return 0;
 238           }return 1;
 239         case MB_SKY:
 240           sky_type=0;read(h,&sky_type,2);
 241           strcpy(w.n,"RSKY1");w.n[4]=sky_type+'0';
 242           M_unlock(horiz);
 243           horiz=M_lock(F_getresid(w.n));
 244           return 1;
 245   }return 0;
 246 }