src/awish.c

   1 /*
   2  * This program is free software: you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation, either version 3 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  */
  15 #include <ctype.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19
  20 #include "SDL.h"
  21 #include "SDL_endian.h"
  22
  23 #ifdef WIN32
  24 # include <windows.h>
  25 #endif
  26
  27 #include "resfile.h"
  28 #include "video.h"
  29 #include "mainloop.h"
  30 #include "vm.h"
  31 #include "gameglobals.h"
  32 #include "game.h"
  33 #include "title.h"
  34 #include "polymod.h"
  35
  36
  37 int goobers = 0;
  38 int datfirst = 0;
  39
  40
  41 ////////////////////////////////////////////////////////////////////////////////
  42 static SDL_Surface *loadCFScreen (const char *fname, SDL_Surface *old, int w, int h, int chained) {
  43   SDL_Surface *new;
  44   static Uint8 pal[256][3];
  45   static Uint32 opal[256];
  46   static Uint8 scr[64000];
  47   int rsz;
  48   uint8_t *diskdata = tryDiskFile(fname, &rsz);
  49   //
  50   if (diskdata == NULL) return old;
  51   if (rsz < w*h+(chained >= 0 ? 768 : 0)) { free(diskdata); return old; }
  52   //
  53   new = createSurface(320*2, 200*2);
  54   if (!new) { free(diskdata); return old; }
  55   SDL_SetColorKey(new, 0, 0); // clear colorkey info (it's the fullscreen image after all!)
  56   //
  57   for (int dy = 0; dy < 200; ++dy) {
  58     for (int dx = 0; dx < 320; ++dx) {
  59       putPixel2x(new, dx, dy, 0);
  60     }
  61   }
  62   //
  63   memcpy(scr, diskdata, w*h);
  64   if (chained >= 0) memcpy(pal, diskdata+w*h, 768);
  65   free(diskdata);
  66   //
  67   if (chained >= 0) {
  68     memcpy(opal, palette, 256*4);
  69     for (int f = 0; f < 256; ++f) {
  70       pal[f][0] <<= 2;
  71       if (pal[f][0] != 0) pal[f][0] |= 3;
  72       pal[f][1] <<= 2;
  73       if (pal[f][1] != 0) pal[f][1] |= 3;
  74       pal[f][2] <<= 2;
  75       if (pal[f][2] != 0) pal[f][2] |= 3;
  76       palette[f] = SDL_MapRGB(screen->format, pal[f][0], pal[f][1], pal[f][2]);
  77     }
  78   }
  79   //
  80   if (chained > 0) {
  81     for (int dy = 0; dy < h; ++dy) {
  82       for (int dx = 0; dx < w/4; ++dx) {
  83         for (int c = 0; c < 4; ++c) {
  84           putPixel2x(new, dx*4+c, dy, scr[dy*(w/4)+(w*h)/4*c+dx]);
  85         }
  86       }
  87     }
  88   } else {
  89     for (int dy = 0; dy < h; ++dy) {
  90       for (int dx = 0; dx < w; ++dx) {
  91         putPixel2x(new, dx, dy, scr[dy*w+dx]);
  92       }
  93     }
  94   }
  95   //
  96   memcpy(palette, opal, 256*4);
  97   SDL_FreeSurface(old);
  98   return new;
  99 }
 100
 101
 102 ////////////////////////////////////////////////////////////////////////////////
 103 static int loadFont (void) {
 104   int sz;
 105   uint8_t *buf = loadResFile(&resfile, 92, &sz);
 106   //
 107   if (buf == NULL) return -1;
 108   if (sz != 256*8) { free(buf); return -1; }
 109   memcpy(font, buf, 256*8);
 110   free(buf);
 111   return 0;
 112 }
 113
 114
 115 static int loadPalette (void) {
 116   int sz;
 117   uint8_t *buf = loadResFile(&resfile, 83, &sz);
 118   //
 119   if (buf == NULL) return -1;
 120   if (sz != 768) { free(buf); return -1; }
 121   for (int f = 0; f < 768; ++f) {
 122     buf[f] <<= 2;
 123     if (buf[f] != 0) buf[f] |= 3;
 124   }
 125   for (int f = 0; f < 256; ++f) palette[f] = SDL_MapRGB(screen->format, buf[f*3+0], buf[f*3+1], buf[f*3+2]);
 126   free(buf);
 127   return 0;
 128 }
 129
 130
 131 static SDL_Surface *loadImage (ResFile *resfile, int idx) {
 132   int sz;
 133   static Uint8 *img;
 134   SDL_Surface *res;
 135   //
 136   img = loadResFile(resfile, idx, &sz);
 137   if (img == NULL) return NULL;
 138   if (sz < 320*200) { free(img); return NULL; }
 139   res = createSurface(320*2, 200*2);
 140   if (res == NULL) { free(img); return NULL; }
 141   SDL_SetColorKey(res, 0, 0); // clear colorkey info (it's the fullscreen image after all!)
 142   for (int f = 0; f < 320*200; ++f) putPixel2x(res, f%320, f/320, img[f]);
 143   free(img);
 144   return res;
 145 }
 146
 147
 148 // return # of sprites loaded or <0 on error
 149 static int loadSpriteBank (SpriteBank *bank, ResFile *resfile, int idx) {
 150   Uint8 *buf;
 151   int sz, pos, cnt;
 152   //
 153   if ((buf = loadResFile(resfile, idx, &sz)) == NULL) return -1;
 154   if (sz < 3) { free(buf); return -1; }
 155   pos = 0;
 156   cnt = 0;
 157   bank->count = 0;
 158   while (pos+4 <= sz) {
 159     int h = ((Uint32)buf[pos+0])+256*((Uint32)buf[pos+1]);
 160     int w = ((Uint32)buf[pos+2])+256*((Uint32)buf[pos+3]);
 161     //
 162     pos += 4;
 163     if (h > 0 && w > 0) {
 164       SDL_Surface *s0 = createSurface(w*2, h*2);
 165       SDL_Surface *s1 = createSurface(w*2, h*2);
 166       //
 167       if (!s0 || !s1) { free(buf); return -1; }
 168       //
 169       for (int y = 0; y < h; ++y) {
 170         for (int x = 0; x < w; ++x) {
 171           if (pos < sz) {
 172             putPixel2x(s0, x, y, buf[pos]);
 173             putPixel2x(s1, w-x-1, y, buf[pos]);
 174             ++pos;
 175           }
 176         }
 177       }
 178       bank->spr[bank->count][0] = s0;
 179       bank->spr[bank->count][1] = s1;
 180       ++(bank->count);
 181     }
 182   }
 183   free(buf);
 184   return cnt;
 185 }
 186
 187
 188 /*
 189 static void freeSpriteBank (SpriteBank *bank) {
 190   for (int f = bank->count-1; f >= 0; --f) {
 191     SDL_FreeSurface(bank->spr[f][1]);
 192     SDL_FreeSurface(bank->spr[f][0]);
 193   }
 194 }
 195 */
 196
 197
 198 ////////////////////////////////////////////////////////////////////////////////
 199 static void quitCleanupRes (void) {
 200   vmFreeLabels();
 201   unloadAllSounds();
 202   deinitResFile(&sndfile);
 203   deinitResFile(&resfile);
 204   //for (int f = 0; f < sizeof(banks)/sizeof(SpriteBank); ++f) freeSpriteBank(&banks[f]);
 205 }
 206
 207
 208 ////////////////////////////////////////////////////////////////////////////////
 209 static int awishRST (int tid, int opcode, int argc, int argv[], int *argp[]) {
 210   vmGVars[GVAR_RST_RESULT] = 0;
 211   //
 212   if (argv[0] == CONST_FRST_ML_TITLE) {
 213     setMainLoopTitle();
 214   } else if (argv[0] == CONST_FRST_ML_GAME) {
 215     setMainLoopGame();
 216   } else if (argv[0] == CONST_FRST_GET_MAX_THREADS) {
 217     vmGVars[GVAR_RST_RESULT] = VM_MAX_THREADS;
 218   } else if (argv[0] == CONST_FRST_GET_MAX_THREAD_ID) {
 219     vmGVars[GVAR_RST_RESULT] = vmLastThread();
 220   } else if (argv[0] == CONST_FRST_GET_RAND) {
 221     int nmin = 0, nmax = 32767;
 222     //
 223     switch (argc) {
 224       case 2: nmax = argv[1]; break;
 225       case 3: nmin = argv[1]; nmax = argv[2]; break;
 226     }
 227     if (nmin >= nmax) {
 228       vmGVars[GVAR_RST_RESULT] = nmin;
 229     } else {
 230       vmGVars[GVAR_RST_RESULT] = nmin+(randUInt32()%(nmax-nmin+1));
 231     }
 232   } else if (argv[0] == CONST_FRST_GET_SEED_H) {
 233     vmGVars[GVAR_RST_RESULT] = getSeedH();
 234   } else if (argv[0] == CONST_FRST_GET_SEED_L) {
 235     vmGVars[GVAR_RST_RESULT] = getSeedL();
 236   } else if (argv[0] == CONST_FRST_SET_SEED_H) {
 237     if (argc >= 2) setSeedH(argv[1]);
 238   } else if (argv[0] == CONST_FRST_SET_SEED_L) {
 239     if (argc >= 2) setSeedL(argv[1]);
 240   } else if (argv[0] == CONST_FRST_DEBUG_PRINT_STR) {
 241     int pos = 0, len = 0;
 242     //
 243     switch (argc) {
 244       case 1:
 245         pos = vmPop(tid);
 246         goto dolen;
 247       case 2:
 248         pos = argv[1];
 249 dolen:  if (pos >= 0) {
 250           while (pos < vmCodeSize && vmCode[pos+len]) ++len;
 251         }
 252         break;
 253       case 3:
 254         pos = argv[1];
 255         len = argv[2];
 256         break;
 257     }
 258     if (goobers) {
 259       if (pos >= -255 && pos <= -1) {
 260         fputc(-pos, stderr);
 261       } else {
 262         for (; len > 0; --len, ++pos) if (pos >= 0 && pos < vmCodeSize) fputc(vmCode[pos], stderr);
 263       }
 264     }
 265   } else if (argv[0] == CONST_FRST_DEBUG_PRINT_NUM) {
 266     switch (argc) {
 267       case 1: argv[1] = vmPop(tid); // fallthru
 268       case 2: if (goobers) fprintf(stderr, "%d", argv[1]); break;
 269       case 3: if (goobers) fprintf(stderr, "%d,%d", argv[1], argv[2]); break;
 270     }
 271   } else if (argv[0] == CONST_FRST_PLAY_SOUND) {
 272     // arg1: sound index; arg2 (if present) channel; rst_result: -1 or channel
 273     if (argc == 1) argv[1] = vmPop(tid);
 274     if (argc < 2) argv[2] = -1;
 275     vmGVars[GVAR_RST_RESULT] = playSound(argv[1], argv[2]);
 276   } else if (argv[0] == CONST_FRST_STOP_CHANNEL) {
 277     // arg1: channel
 278     if (argc == 1) argv[1] = vmPop(tid);
 279     vmGVars[GVAR_RST_RESULT] = stopChannel(argv[1]);
 280   } else if (argv[0] == CONST_FRST_IS_CHANNEL_PLAYING) {
 281     // arg1: channel; rst_result: bool
 282     if (argc == 1) argv[1] = vmPop(tid);
 283     vmGVars[GVAR_RST_RESULT] = isChannelPlaying(argv[1]);
 284   } else if (argv[0] == CONST_FRST_LOAD_SOUND) {
 285     // arg1: sound index; rst_result: bool
 286     if (argc == 1) argv[1] = vmPop(tid);
 287     vmGVars[GVAR_RST_RESULT] = loadSound(argv[1]) ? 0 : 1;
 288   } else if (argv[0] == CONST_FRST_UNLOAD_SOUND) {
 289     // arg1: sound index; rst_result: bool
 290     if (argc == 1) argv[1] = vmPop(tid);
 291     vmGVars[GVAR_RST_RESULT] = unloadSound(argv[1]) ? 0 : 1;
 292   } else if (argv[0] == CONST_FRST_IS_SOUND_LOADED) {
 293     // arg1: sound index; rst_result: bool
 294     if (argc == 1) argv[1] = vmPop(tid);
 295     vmGVars[GVAR_RST_RESULT] = isSoundLoaded(argv[1]) ? 0 : 1;
 296   } else {
 297     if (gameRSTCB) return gameRSTCB(tid, opcode, argc, argv, argp);
 298     fatal("invalid RST: %d", argv[0]);
 299   }
 300   return 0; // continue
 301 }
 302
 303
 304 ////////////////////////////////////////////////////////////////////////////////
 305 static int checkLevelCode (const char *t) {
 306   int ctrd;
 307   //
 308   if (!t || !t[0]) return -1;
 309   ctrd = vmNewThread(0);
 310   for (int level = 0; level < vmGVars[GVAR_MAX_LEVEL]; ++level) {
 311     //fprintf(stderr, "%d/%d\n", level+1, vmGVars[GVAR_MAX_LEVEL]);
 312     vmPush(ctrd, level);
 313     if (vmExecuteBSR(ctrd, CODE_ENTRY_GET_LEVEL_CODE, 0) == 0) {
 314       int pos = vmGVars[GVAR_LEVEL_CODE_OFS], len = vmGVars[GVAR_LEVEL_CODE_LEN], ok = 1;
 315       //
 316       if (strlen(t) == len && pos >= 0 && len > 0 && pos+len <= vmCodeSize) {
 317         //fwrite(vmCode+pos, len, 1, stderr);
 318         //fprintf(stderr, " [%s]\n", t);
 319         for (int f = 0; f < len; ++f) {
 320           //fprintf(stderr, "%c %c\n", tolower(t[f]), tolower(vmCode[pos+f]));
 321           if (tolower(t[f]) != tolower(vmCode[pos+f])) { ok = 0; break; }
 322         }
 323         if (ok) {
 324           if (goobers) fprintf(stderr, "found code for level #%02d\n", level+1);
 325           return level;
 326         }
 327       }
 328     } else {
 329       if (goobers) fprintf(stderr, "sorry!\n");
 330       break;
 331     }
 332   }
 333   vmKillThread(ctrd);
 334   return -1;
 335 }
 336
 337
 338 ////////////////////////////////////////////////////////////////////////////////
 339 #ifdef _WIN32
 340 # include "cmdline.c"
 341 #endif
 342
 343
 344 ////////////////////////////////////////////////////////////////////////////////
 345 int main (int argc, char *argv[]) {
 346   int csz;
 347   //
 348 #ifdef _WIN32
 349   cmdLineParse();
 350   argc = k8argc;
 351   argv = k8argv;
 352 #endif
 353   //
 354   polymodInitialize();
 355   //
 356   for (int f = 1; f < argc; ++f) {
 357     int eaten = 1;
 358     //
 359     if (strcmp(argv[f], "-goobers") == 0) goobers = 1;
 360     else if (strcmp(argv[f], "-dat") == 0) datfirst = 1;
 361     else if (strcmp(argv[f], "-trace") == 0) vmDebugTrace = 1;
 362     else if (strcmp(argv[f], "-tracelog") == 0) {
 363       eaten = 1;
 364       vmDebugTrace = 1;
 365       vmDebugOutput = fopen("ztrace.log", "w");
 366     } else {
 367       eaten = 0;
 368     }
 369     if (eaten > 0) {
 370       for (int c = f+eaten; c < argc; ++c) argv[c-1] = argv[c];
 371       argv[argc -= eaten] = NULL;
 372       f -= eaten;
 373     }
 374   }
 375   //
 376   initResFile(&resfile, "RESOURCE.DAT");
 377   initResFile(&sndfile, "RESOURCE.SND");
 378   atexit(quitCleanupRes);
 379   //
 380   if (loadFont() != 0) {
 381     fprintf(stderr, "FATAL: can't load font!\n");
 382     exit(1);
 383   }
 384   //
 385   sdlInit();
 386   initVideo();
 387   //
 388   if (loadPalette() != 0) {
 389     fprintf(stderr, "FATAL: can't load palette!\n");
 390     exit(1);
 391   }
 392   //
 393   {
 394     SurfaceLock lock;
 395     //
 396     lockSurface(&lock, screen);
 397     drawString(screen, "loading...", 2, 200-10, 1);
 398     unlockSurface(&lock);
 399     SDL_Flip(screen);
 400   }
 401   //
 402   for (int f = 0; f < 8; ++f) {
 403     if ((backs[(f+1)%8] = loadImage(&resfile, f)) == NULL) {
 404       fprintf(stderr, "FATAL: can't load image #%d!\n", f);
 405       exit(1);
 406     }
 407   }
 408   //
 409   backs[0] = loadCFScreen("CFTITLE.DAT", backs[0], 320, 200, 1);
 410   backs[0] = loadCFScreen("cftitle.dat", backs[0], 320, 200, 1);
 411   //
 412   memset(banks, 0, sizeof(banks));
 413   for (int f = 84; f <= 90; ++f) {
 414     if (loadSpriteBank(&banks[f], &resfile, f)) {
 415       fprintf(stderr, "FATAL: can't load sprint bank #%d!\n", f);
 416       exit(1);
 417     }
 418   }
 419   //
 420   if (vmInitialize() != 0) fatal("can't init VM");
 421   //
 422   memset(vmGVars, 0, sizeof(vmGVars));
 423   vmRSTCB = awishRST;
 424   //
 425   vmAddLabel("flag_skip_title", LB_GVAR, 120, 1); // 1: public
 426   vmGVars[120] = 0;
 427   //
 428   vmCodeSize = 0;
 429   if ((csz = loadCodeFile(&resfile, vmCodeSize, 93)) < 1) {
 430     fprintf(stderr, "FATAL: can't load VM code!\n");
 431     exit(1);
 432   }
 433   vmCodeSize += csz;
 434   initLabels();
 435   //
 436   //vmGVars[GVAR_KEY_QUIT] = 0;
 437   //vmGVars[GVAR_KEY_START] = 0;
 438   vmGVars[GVAR_GOOBERS] = goobers;
 439   //
 440   vmSetPC(0, CODE_ENTRY_TITLE);
 441   if (vmExecuteBSR(0, CODE_ENTRY_MAIN_INIT, 0) != 0) fatal("can't initialize game");
 442   if (goobers) fprintf(stderr, "MAX LEVEL: %d\n", vmGVars[GVAR_MAX_LEVEL]);
 443   //
 444   if (argc > 1) {
 445     // check level code
 446     for (int f = 1; f < argc; ++f) {
 447       int lvl = checkLevelCode(argv[f]);
 448       //
 449       if (lvl >= 0) {
 450         vmGVars[GVAR_START_LEVEL] = lvl;
 451         break;
 452       }
 453     }
 454   }
 455   //
 456   mainLoop();
 457   //
 458   return 0;
 459 }
 460
 461
 462 #ifdef WIN32
 463 int CALLBACK WinMain (HINSTANCE hInstance, HINSTANCE unused__, LPSTR lpszCmdLine, int nCmdShow) {
 464   char *shit[] = { (char *)"shit", NULL };
 465   return SDL_main(1, shit);
 466 }
 467 #endif