Logo Search packages:      
Sourcecode: sarien version File versions  Download package

agi_v2.c

/*  Sarien - A Sierra AGI resource interpreter engine
 *  Copyright (C) 1999-2001 Stuart George and Claudio Matsuoka
 *  
 *  $Id: agi_v2.c,v 1.41 2002/04/03 21:08:25 cmatsuoka Exp $
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; see docs/COPYING for further details.
 */

#ifndef PALMOS

#include <stdio.h>
#include <string.h>
#include "sarien.h"
#include "agi.h"

static int agi_v2_init (void);
static int agi_v2_deinit (void);
static int agi_v2_detect_game (char *);
static int agi_v2_load_resource (int, int);
static int agi_v2_unload_resource (int, int);
static int agi_v2_load_objects(char *);
static int agi_v2_load_words(char *);

struct agi_loader agi_v2 = {
      2,
      0,
      agi_v2_init,
      agi_v2_deinit,
      agi_v2_detect_game,
      agi_v2_load_resource,
      agi_v2_unload_resource,
      agi_v2_load_objects,
      agi_v2_load_words
};


static int agi_v2_detect_game (char *gn)
{
      strncpy (game.dir, gn, MAX_PATH);
      _D (_D_WARN "game.dir = %s", game.dir);

      if (  !file_isthere (fixpath (NO_GAMEDIR, LOGDIR)) ||
            !file_isthere (fixpath (NO_GAMEDIR, PICDIR)) ||
            !file_isthere (fixpath (NO_GAMEDIR, SNDDIR)) ||
            !file_isthere (fixpath (NO_GAMEDIR, VIEWDIR)))
      {
            return err_InvalidAGIFile;
      }

      agi_v2.int_version = 0x2917;        /* setup for 2.917 */
#ifdef __MPW__
      return err_OK;
#else
      return v2id_game ();
#endif
}


static int agi_v2_load_dir (struct agi_dir *agid, char *fname)
{
      FILE *fp;
      UINT8 *mem;
      UINT32 flen;
      unsigned int i;
      char *path;

      path = fixpath (NO_GAMEDIR, fname);
      report ("Loading directory: %s\n", path);

      if ((fp = fopen (path, "rb")) == NULL) {
            return err_BadFileOpen;
      }

      fseek (fp, 0, SEEK_END);
      flen = ftell (fp);
      fseek (fp, 0, SEEK_SET);

      if ((mem = malloc (flen + 32)) == NULL) {
            fclose (fp);
            return err_NotEnoughMemory;
      }

      fread (mem, 1, flen, fp);

      /* set all directory resources to gone */
      for (i = 0; i < MAX_DIRS; i++) {
            agid[i].volume = 0xff;
            agid[i].offset = _EMPTY;
      }

      /* build directory entries */
      for (i = 0; i < flen; i += 3) {
            agid[i / 3].volume = hilo_getbyte (mem + i) >> 4;
            agid[i / 3].offset = hilo_getpword (mem + i) & (UINT32)_EMPTY;
            /* _D ("%d: volume %d, offset 0x%05x", i / 3,
                  agid[i / 3].volume, agid[i / 3].offset); */
      }

      free (mem);
      fclose (fp);

      return err_OK;
}


static int agi_v2_init ()
{
      int ec = err_OK;

      /* load directory files */
      ec = agi_v2_load_dir (game.dir_logic, LOGDIR);
      if (ec == err_OK)
            ec = agi_v2_load_dir (game.dir_pic, PICDIR);
      if (ec == err_OK)
            ec = agi_v2_load_dir (game.dir_view, VIEWDIR);
      if (ec == err_OK)
            ec = agi_v2_load_dir (game.dir_sound, SNDDIR);

      return ec;
}


static int agi_v2_deinit ()
{
      int ec = err_OK;

#if 0
      /* unload words */
      agi_v2_unload_words ();

      /* unload objects */
      agi_v2_unload_objects ();
#endif

      return ec;
}

static int agi_v2_unload_resource (int t, int n)
{
      /* _D ("unload resource"); */

      switch (t) {
      case rLOGIC:
            unload_logic (n);
            break;
      case rPICTURE:
            unload_picture (n);
            break;
      case rVIEW:
            unload_view (n);
            break;
      case rSOUND:
            unload_sound (n);
            break;
      }

      return err_OK;
}


/*
 * This function does noting but load a raw resource into memory,
 * if further decoding is required, it must be done by another
 * routine. NULL is returned if unsucsessfull.
 */

static UINT8* agi_v2_load_vol_res (struct agi_dir *agid)
{
      UINT8 *data = NULL;
      char x[MAX_PATH], *path;
      FILE *fp;
      unsigned int sig;

      sprintf (x, "vol.%i", agid->volume);
      path = fixpath (NO_GAMEDIR, x);
      _D ("path = %s", path);

      if (agid->offset != _EMPTY && (fp = fopen (path, "rb")) != NULL) {
            _D ("loading resource at offset %d", agid->offset);
            if (fseek (fp, agid->offset, SEEK_SET) < 0) {
                  agid->offset = _EMPTY;
                  return NULL;
            }
            fread (&x, 1, 5, fp);
            if ((sig = hilo_getword ((UINT8*)x)) == 0x1234) {
                  agid->len = lohi_getword ((UINT8*)x + 3);
                  data = calloc (1, agid->len + 32);
                  if (data != NULL) {
                        fread (data, 1, agid->len, fp);
                  } else {
                        abort ();
                  }
            } else {
#if 0
                  /* FIXME: call some panic handler instead of
                   *        deiniting directly
                   */
                  deinit_video_mode ();
#endif
                  report ("Error: bad signature %04x\n", sig);
                  /* fprintf (stderr, "ACK! BAD RESOURCE!!!\n"); */
                  return 0;
            }
            fclose (fp);
      } else {
            /* we have a bad volume resource */
            /* set that resource to NA */
            agid->offset = _EMPTY;
      }

      return data;
}


/*
 * Loads a resource into memory, a raw resource is loaded in
 * with above routine, then further decoded here.
 */
int agi_v2_load_resource (int t, int n)
{
      int ec = err_OK;
      UINT8 *data = NULL;

      _D (_D_WARN "(t = %d, n = %d)", t, n);
      if (n > MAX_DIRS)
            return err_BadResource;

      switch (t) {
      case rLOGIC:
            if (~game.dir_logic[n].flags & RES_LOADED) {
                  _D (_D_WARN "loading logic resource %d", n);
                  agi_v2.unload_resource (rLOGIC, n);

                  /* load raw resource into data */
                  data = agi_v2_load_vol_res (&game.dir_logic[n]);

                  game.logics[n].data = data;
                  ec = data ? decode_logic (n) : err_BadResource;

                  game.logics[n].sIP = 2;
                  }

            /* if logic was cached, we get here */
            /* reset code pointers incase it was cached */

            game.logics[n].cIP = game.logics[n].sIP;
            break;
      case rPICTURE:
            /* if picture is currently NOT loaded *OR* cacheing is off,
             * unload the resource (caching == off) and reload it
             */

            _D (_D_WARN "loading picture resource %d", n);
            if (game.dir_pic[n].flags & RES_LOADED)
                  break;

            /* if loaded but not cached, unload it */
            /* if cached but not loaded, etc */
            agi_v2.unload_resource (rPICTURE, n);
            data = agi_v2_load_vol_res (&game.dir_pic[n]);

            if (data != NULL) {
                  game.pictures[n].rdata = data;
                  game.dir_pic[n].flags |= RES_LOADED;
            } else {
                  ec = err_BadResource;
            }
            break;
      case rSOUND:
            _D (_D_WARN "loading sound resource %d", n);
            if (game.dir_sound[n].flags & RES_LOADED)
                  break;

            data = agi_v2_load_vol_res (&game.dir_sound[n]);

            if (data != NULL) {
                  game.sounds[n].rdata = data;
                  game.dir_sound[n].flags |= RES_LOADED;
                  decode_sound (n);
            } else {
                  ec = err_BadResource;
            }
            break;
      case rVIEW:
            /* Load a VIEW resource into memory...
             * Since VIEWS alter the view table ALL the time
             * can we cache the view? or must we reload it all
             * the time?
             */
            if (game.dir_view[n].flags & RES_LOADED)
                  break;

            _D (_D_WARN "loading view resource %d", n);
            agi_v2.unload_resource (rVIEW, n);
            data = agi_v2_load_vol_res (&game.dir_view[n]);
            if (data) {
                  game.views[n].rdata = data;
                  game.dir_view[n].flags |= RES_LOADED;
                  ec = decode_view (n);
            } else {
                  ec=err_BadResource;
            }
            break;
      default:
            ec = err_BadResource;
            break;
      }

      return ec;
}

static int agi_v2_load_objects(char *fname)
{
      return load_objects(fname);
}

static int agi_v2_load_words(char *fname)
{
      return load_words(fname);
}

#endif /* PALMOS */

Generated by  Doxygen 1.6.0   Back to index