replay.c

/*
    Copyright (C) 2005 Michael K. McCarty & Fritz Bronner

    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; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
// Interplay's BUZZ ALDRIN's RACE into SPACE
//
// Formerly -=> LiftOff : Race to the Moon :: IBM version MCGA
// Copyright 1991 by Strategic Visions, Inc.
// Designed by Fritz Bronner
// Programmed by Michael K McCarty
//
#include <gamedata.h>
#include <Buzz_inc.h>
#include <externs.h>
#include <assert.h>
#include <mmfile.h>
#include <av.h>
#include <logging.h>

#ifdef DEADCODE

#define FRM_Delay		25

#define STL_OFF			26715
#define ANIM_PARTS		297

extern char STEPnum, loc[4];
extern struct MisEval Mev[60];
extern char MANNED[2], STEP, pal2[768], AI[2];
extern int tFrames, cFrame;
extern long aLoc;
extern GXHEADER dply;
extern struct AnimType AHead;
extern struct BlockHead BHead;
#endif

LOG_DEFAULT_CATEGORY(LOG_ROOT_CAT)

#if 0
void
RLEF(char *dest, char *src, unsigned int src_size)
{
	asm push es;				// preserve ES
	asm push ds;				// preserve DS
	asm les di, dest;			// move dest into ES:DI
	asm lds si, src;			// move src into DS:SI
	asm mov cx, 0;				// clear CX
	asm mov bx, src_size;		// move counter into BX

  loa:
	asm lodsb;					   // move byte into AL
	asm dec bx;					// decrement CX
	asm cmp al, 0;				// compare AL to 0
	asm jl repeat;				// if al < 0 jump to repeat

	// copy bytes
	asm mov ah, 0;				// clear AH
	asm inc al;					// increment AL
	asm mov cl, al;				// put value of AL into CL
	asm rep movsb;				// move CX bytes from DS:SI to ES:DI
	asm sub bx, ax;				// increment BX by approp value
	asm cmp bx, 0;				// see if finished
	asm jg loa;					// if not then loop
	asm jmp bot;				// else jump to bottom

  repeat:
	asm neg al;					   // negate AL
	asm inc al;					// increment AL by 1
	asm mov cl, al;				// move counter value to CX
	asm lodsb;					// load value to copy

  lob:
	asm stosb;					   // copy AL into ES:DI
	asm loop lob;				// do while CX >0
	asm dec bx;					// decrement bx;

	asm cmp bx, 100 h;
	asm jg sk;
	asm int 03 h;

  sk:
	asm cmp bx, 0;				   // see if finished
	asm jg loa;					// if not then loop

  bot:							   // bottom of routine
	asm pop ds;					   // restore ds
	asm pop es;					// restore es

	return;
}
#endif

/** find and fill REPLAY structure and return 0, or -1 if failed.
 * if grp != NULL and oGROUP at offset rep->off[0] is found, then fill grp too
 * 
 * \return -1 on bad sequence
 * \return  0 in all other cases
 */
static int
find_replay(REPLAY * rep, struct oGROUP *grp, char player, int num,
	const char *type)
{
	FILE *fseq = NULL;
	struct oGROUP group;
	size_t offset = 0;
	int retval = 0;

	assert(rep);

	/** \note uses SEQ.DAT */
	fseq = sOpen("SEQ.DAT", "rb", 0);
	if (!fseq)
		return -1;

	if (strncmp("OOOO", type, 4) == 0)
	{
		FILE *f = sOpen("REPLAY.DAT", "rb", 1);

		offset = (player * 100) + num;
		fseek(f, offset * (sizeof *rep), SEEK_SET);
		/** \todo Uses fread() here - should be fread_REPLAY(&Rep, 1, f); */
		fread(rep, (sizeof *rep), 1, f);
		fclose(f);
		if (grp && fseek(fseq, sizeof_oGROUP * rep->Off[0], SEEK_SET) == 0)
			fread_oGROUP(grp, 1, fseq);
	}
	else
	{
		int j = 0;

		while (fread_oGROUP(&group, 1, fseq))
		{
			if (strncmp(group.ID, "XXXX", 4) == 0)
			{
				/* bad sequence? */
				retval = -1;
				goto done;
			}
			if (strcmp(&group.ID[3], type) == 0)
				break;
			j++;
		}
		rep->Qty = 1;
		rep->Off[0] = j;
		if (grp)
			memcpy(grp, &group, sizeof(group));
	}
  done:
	if (fseq)
		fclose(fseq);

	return retval;
}

/**
 * 
 * \returns nothing if find_replay() fails
 * \returns nothing if it can't open the [f]seq.dat file
 */
void
Replay(char plr, int num, int dx, int dy, int width, int height, char *Type)
{
	int keep_going;
	int i, kk, mode, max;
	FILE *seqf, *fseqf;
	long offset;
	struct oGROUP group;
	struct oFGROUP fgroup;
	struct Table table;
	REPLAY Rep;

	mm_file vidfile;
	float fps;
	double last_time;
	if (find_replay(&Rep, NULL, plr, num, Type) < 0)
		return;

	/** \note uses SEQ.DAT
	 *  \note uses FSEQ.DAT
	 */
	seqf = sOpen("SEQ.DAT", "rb", 0);
	fseqf = sOpen("FSEQ.DAT", "rb", 0);

	if (!seqf || !fseqf)
	{
		if (!seqf)
			fclose(seqf);
		if (!fseqf)
			fclose(fseqf);
		return;
	}

	WaitForMouseUp();

    DEBUG2("video sequence: %d segments", Rep.Qty);
	for (kk = 0; kk < Rep.Qty; kk++)
	{
		DEBUG3("playing segment %d: %d", kk, Rep.Off[kk]);
		if (Rep.Off[kk] < 1000)	   //Specs: success seq
		{
			fseek(seqf, Rep.Off[kk] * sizeof_oGROUP, SEEK_SET);
			fread_oGROUP(&group, 1, seqf);
			max = group.ID[1] - '0';
			mode = 0;
		}
		else
		{						   //Specs: failure seq
			int j = 0;
			// MAX 50 Tables
			i = Rep.Off[kk] / 1000;
			j = Rep.Off[kk] % 1000;
			if (i == 0 || i == 50)
				goto done;
			i--;				   //Specs: offset index klugge
			fseek(fseqf, i * sizeof_Table, SEEK_SET);
			fread_Table(&table, 1, fseqf);
			offset = table.foffset;
			fseek(fseqf, offset + j * sizeof_oFGROUP, SEEK_SET);
			fread_oFGROUP(&fgroup, 1, fseqf);
			mode = 1;
			max = fgroup.ID[1] - '0';
		};

		i = 0;
		keep_going = 1;
		//	update_map = 0;
		while (keep_going && i < max)
		{
			int frm_idx;
			char *seq_fname = NULL;
			char fname[20];

			if (mode == 1)		   /* failure */
				frm_idx = fgroup.oLIST[i].aIdx;
			else
				frm_idx = group.oLIST[i].aIdx;

			/* here we should create YUV Overlay, but we can't use it on
			 * pallettized surface, so we use a global Overlay initialized in
			 * sdl.c. */
			seq_fname = seq_filename(frm_idx, mode);
			if (!seq_fname)
				seq_fname = "(unknown)";

			/** \todo assumption on file extension */
			snprintf(fname, sizeof(fname), "%s.ogg", seq_fname);

			INFO2("opening video file `%s'", fname);

			if (mm_open_fp(&vidfile, sOpen(fname, "rb", FT_VIDEO)) <= 0)
				goto done;

			/** \todo do not ignore width/height */
			if (mm_video_info(&vidfile, NULL, NULL, &fps) <= 0)
				goto done;

			last_time = get_time();

			while (keep_going)
			{
				video_rect.x = dx;
				video_rect.y = dy;
				video_rect.w = width;
				video_rect.h = height;

				screen_dirty = 1;

				/** \todo track decoding time and adjust delays */
				if (mm_decode_video(&vidfile, video_overlay) <= 0)
					break;

				if (bioskey(0) || grGetMouseButtons())
					keep_going = 0;

				/** \todo idle_loop is too inaccurate for this */
				idle_loop_secs(1.0 / fps);
			}

			mm_close(&vidfile);
			i++;
		}
	}
  done:
	mm_close(&vidfile);
	video_rect.w = 0;
	video_rect.h = 0;
	fclose(fseqf);
	fclose(seqf);
	return;
}

void
DispBaby(int x, int y, int loc, char neww)
{
	int i;
	FILE *fin;
	GXHEADER boob;
	ui16 *bot, off = 0;
	long locl;

	off = 224;

	GV(&boob, 68, 46);
	bot = (ui16 *) boob.vptr;

	fin = sOpen("BABYPICX.CDR", "rb", 0);
	locl = (long) 1612 *loc;	// First Image

	fseek(fin, locl, SEEK_SET);
	for (i = 0; i < 48; i++)
		pal[off * 3 + i] = 0;
	if (neww)
		gxSetDisplayPalette(pal);
	fread(&pal[off * 3], 48, 1, fin);
	fread(boob.vptr, 1564, 1, fin);
	fclose(fin);

	for (i = 0; i < 782; i++)
	{
		bot[i + 782] = ((bot[i] & 0xF0F0) >> 4);
		bot[i] = (bot[i] & 0x0F0F);
	}
	for (i = 0; i < 1564; i++)
	{
		boob.vptr[i] += off;
		boob.vptr[1564 + i] += off;
	}

	gxPutImage(&boob, gxSET, x, y, 0);
	if (neww)
		gxSetDisplayPalette(pal);
	DV(&boob);

	return;
}

void
AbzFrame(char plr, int num, int dx, int dy, int width, int height,
	char *Type, char mode)
{
	int idx = 0;
	struct oGROUP grp;
	REPLAY Rep;

	/* force mode to zero */
	mode = 0;

	char fname[100];
	mm_file vidfile;

	memset(&grp, 0, sizeof grp);

	if (find_replay(&Rep, &grp, plr, num, Type) < 0)
		return;

	idx = grp.oLIST[0].aIdx;

	/* XXX use a generic function */
	snprintf(fname, sizeof(fname), "%s.ogg", seq_filename(idx, mode));

	INFO2("opening video file `%s'", fname);
	if (mm_open_fp(&vidfile, sOpen(fname, "rb", FT_VIDEO)) <= 0)
		return;

	if (mm_video_info(&vidfile, NULL, NULL, NULL) <= 0)
		goto done;

	if (mm_decode_video(&vidfile, video_overlay) <= 0)
		goto done;

	video_rect.x = dx;
	video_rect.y = dy;
	video_rect.w = width;
	video_rect.h = height;

  done:
	mm_close(&vidfile);
}