cmake_minimum_required(VERSION 2.6)

FILE(GLOB SRC *.c *.cpp)

ADD_EXECUTABLE(spectrum_frotz_backend ${SRC})

target_link_libraries(spectrum_frotz_backend transport pthread)

INSTALL(TARGETS spectrum_frotz_backend RUNTIME DESTINATION bin)

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 */

#include "frotz.h"

extern void stream_char (zchar);

extern void stream_word (const zchar *);

extern void stream_new_line (void);

static zchar buffer[TEXT_BUFFER_SIZE];

static int bufpos = 0;

static zchar prev_c = 0;

/*

 * flush_buffer

 *

 * Copy the contents of the text buffer to the output streams.

 *

 */

void flush_buffer (void)

{

    /* Make sure we stop when flush_buffer is called from flush_buffer.

       Note that this is difficult to avoid as we might print a newline

       during flush_buffer, which might cause a newline interrupt, that

       might execute any arbitrary opcode, which might flush the buffer. */

    if (locked || bufpos == 0)

	return;

    /* Send the buffer to the output streams */

    buffer[bufpos] = 0;

    locked = TRUE;

    stream_word (buffer); 

#ifdef SPEECH_OUTPUT

    os_speech_output(buffer);

#endif

    locked = FALSE;

    /* Reset the buffer */

    bufpos = 0;

    prev_c = 0;

}/* flush_buffer */

/*

 * print_char

 *

 * High level output function.

 *

 */

void print_char (zchar c)

{

    if (message || ostream_memory || enable_buffering) {

	if (!flag) {

	    /* Characters 0 and ZC_RETURN are special cases */

	    if (c == ZC_RETURN)

		{ new_line (); return; }

	    if (c == 0)

		return;

	    /* Flush the buffer before a whitespace or after a hyphen */

	    if (c == ' ' || c == ZC_INDENT || c == ZC_GAP || (prev_c == '-' && c != '-'))

		flush_buffer ();

	    /* Set the flag if this is part one of a style or font change */

	    if (c == ZC_NEW_FONT || c == ZC_NEW_STYLE)

		flag = TRUE;

/*

 * storew

 *

 * Write a word value to the dynamic Z-machine memory.

 *

 */

void storew (zword addr, zword value)

{

    storeb ((zword) (addr + 0), hi (value));

    storeb ((zword) (addr + 1), lo (value));

}/* storew */

/*

 * z_restart, re-load dynamic area, clear the stack and set the PC.

 *

 * 	no zargs used

 *

 */

void z_restart (void)

{

    flush_buffer ();

    os_restart_game (RESTART_BEGIN);

    seed_random (0);

    if (!first_restart) {

	fseek (story_fp, 0, SEEK_SET);

	if (fread (zmp, 1, h_dynamic_size, story_fp) != h_dynamic_size)

	    os_fatal ("Story file read error");

    } else first_restart = FALSE;

    restart_header ();

    restart_screen ();

    sp = fp = stack + STACK_SIZE;

    frame_count = 0;

    if (h_version != V6) {

 * 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.

 *

 * Frotz 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

 */

#include <stdio.h>

#include <string.h>

#include "frotz.h"

#ifndef SEEK_SET

#define SEEK_SET 0

#define SEEK_CUR 1

#define SEEK_END 2

#endif

char script_name[MAX_FILE_NAME + 1] = DEFAULT_SCRIPT_NAME;

char command_name[MAX_FILE_NAME + 1] = DEFAULT_COMMAND_NAME;

#ifdef __MSDOS__

extern char latin1_to_ibm[];

#endif

static int script_width = 0;

static FILE *sfp = NULL;

static FILE *rfp = NULL;

static FILE *pfp = NULL;

/*

 * script_open

 *

 * Open the transscript file. 'AMFV' makes this more complicated as it

 * turns transscription on/off several times to exclude some text from

 * the transscription file. This wasn't a problem for the original V4

 * interpreters which always sent transscription to the printer, but it

 * means a problem to modern interpreters that offer to open a new file

 * every time transscription is turned on. Our solution is to append to

 * the old transscription file in V1 to V4, and to ask for a new file

 * name in V5+.

 *

 */

void script_open (void)

{

    char new_name[MAX_FILE_NAME + 1];

    h_flags &= ~SCRIPTING_FLAG;

    if (h_version >= V5 || !script_valid) {

	if (!os_read_file_name (new_name, script_name, FILE_SCRIPT))

	    goto done;

	strcpy (script_name, new_name);

    }

    /* Opening in "at" mode doesn't work for script_erase_input... */

    if ((sfp = fopen (script_name, "r+t")) != NULL || (sfp = fopen (script_name, "w+t")) != NULL) {

	fseek (sfp, 0, SEEK_END);

	h_flags |= SCRIPTING_FLAG;

	script_valid = TRUE;

	ostream_script = TRUE;

}/* record_open */

/*

 * record_close

 *

 * Stop recording the player's input.

 *

 */

void record_close (void)

{

    fclose (rfp); ostream_record = FALSE;

}/* record_close */

/*

 * record_code

 *

 * Helper function for record_char.

 *

 */

{

    if (force_encoding || c == '[' || c < 0x20 || c > 0x7e) {

	int i;

	fputc ('[', rfp);

	for (i = 10000; i != 0; i /= 10)

	    if (c >= i || i == 1)

		fputc ('0' + (c / i) % 10, rfp);

	fputc (']', rfp);

    } else fputc (c, rfp);

}/* record_code */

/*

 * record_char

 *

 * Write a character to the command file.

 *

 */

/*

 * frotz.h

 *

 * Global declarations and definitions

 *

 */

   But since no os_* function uses it, it's safe to let the frotz core see

   this definition, but have the unix port see the curses version. */

/* #include "../config.h" */

#ifndef __UNIX_PORT_FILE

#include <signal.h>

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE 0

#endif

#endif /* __UNIX_PORT_FILE */

#include <stdio.h>

typedef unsigned char zbyte;

typedef unsigned short zword;

enum story {

    BEYOND_ZORK,

    SHERLOCK,

    ZORK_ZERO,

    SHOGUN,

    ARTHUR,

extern zword h_alphabet;

extern zword h_extension_table;

extern zbyte h_user_name[8];

extern zword hx_table_size;

extern zword hx_mouse_x;

extern zword hx_mouse_y;

extern zword hx_unicode_table;

/*** Various data ***/

extern char *story_name;

extern enum story story_id;

extern long story_size;

extern zword stack[STACK_SIZE];

extern zword *sp;

extern zword *fp;

extern zword frame_count;

extern zword zargs[8];

extern int zargc;

extern int cwin;

extern int mwin;

extern int mouse_x;

extern int mouse_y;

extern char *option_zcode_path;	/* dg */

extern long reserve_mem;

/*** Blorb stuff ***/

/*

bb_err_t       blorb_err;

bb_map_t       *blorb_map;

*/

/*** Z-machine opcodes ***/

void 	z_add (void);

void 	z_and (void);

void 	z_art_shift (void);

void 	z_buffer_mode (void);

void 	z_call_n (void);

void 	z_call_s (void);

void 	z_catch (void);

void 	z_check_arg_count (void);

void	z_check_unicode (void);

#define ERR_REPORT_ONCE (1)

#define ERR_REPORT_ALWAYS (2)

#define ERR_REPORT_FATAL (3)

#define ERR_DEFAULT_REPORT_MODE ERR_REPORT_ONCE

/*** Various global functions ***/

zchar	translate_from_zscii (zbyte);

zbyte	translate_to_zscii (zchar);

void 	flush_buffer (void);

void	new_line (void);

void	print_char (zchar);

void	print_num (zword);

void	print_object (zword);

void 	print_string (const char *);

void 	stream_mssg_on (void);

void 	stream_mssg_off (void);

void	ret (zword);

void 	store (zword);

void	storeb (zword, zbyte);

void	storew (zword, zword);

/*** Interface functions ***/

void 	os_beep (int);

int  	os_char_width (zchar);

void 	os_display_char (zchar);

void 	os_display_string (const zchar *);

void 	os_draw_picture (int, int, int);

void 	os_erase_area (int, int, int, int);

void 	os_fatal (const char *);

void 	os_finish_with_sample (int);

int  	os_font_data (int, int *, int *);

void 	os_init_screen (void);

void 	os_more_prompt (void);

int  	os_peek_colour (void);

int  	os_picture_data (int, int *, int *);

void 	os_prepare_sample (int);

void 	os_process_arguments (int, char *[]);

int	os_random_seed (void);

int  	os_read_file_name (char *, const char *, int);

zchar	os_read_key (int, int);

zchar	os_read_line (int, zchar *, int, int, int);

void 	os_reset_screen (void);

void 	os_restart_game (int);

void 	os_scroll_area (int, int, int, int, int);

void 	os_set_colour (int, int);

void 	os_set_cursor (int, int);

void 	os_set_font (int);

void 	os_set_text_style (int);

void 	os_start_sample (int, int, int, zword);

void 	os_stop_sample (int);

int  	os_string_width (const zchar *);

void	os_init_setup (void);

int	os_speech_output(const zchar *);

#include "setup.h"

 *

 * This file is part of Frotz.

 *

 * Frotz 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.

 *

 * Frotz 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

 */

#include "frotz.h"

extern int restore_undo (void);

extern int read_number (void);

extern void replay_open (void);

extern void replay_close (void);

extern void record_open (void);

extern void record_close (void);

extern void seed_random (int);

/*

 * hot_key_debugging

 *

 * ...allows user to toggle cheating options on/off.

 *

 */

{

    print_string ("Debugging options\n");

    f_setup.attribute_assignment = read_yes_or_no ("Watch attribute assignment");

    f_setup.attribute_testing = read_yes_or_no ("Watch attribute testing");

    f_setup.object_movement = read_yes_or_no ("Watch object movement");

    f_setup.object_locating = read_yes_or_no ("Watch object locating");

    return FALSE;

}/* hot_key_debugging */

/*

 * hot_key_help

 *

 * ...displays a list of all hot keys.

 *

 */

    print_string ("Help\n");

    print_string (

	"\n"

	"Alt-D  debugging options\n"

	"Alt-H  help\n"

	"Alt-N  new game\n"

	"Alt-P  playback on\n"

	"Alt-R  recording on/off\n"

	"Alt-S  seed random numbers\n"

	"Alt-U  undo one turn\n"

	"Alt-X  exit game\n");

    return FALSE;

}/* hot_key_help */

/*

 * hot_key_playback

 *

 * ...allows user to turn playback on.

 *

 */

{

    print_string ("Playback on\n");

    if (!istream_replay)

	replay_open ();

    return FALSE;

}/* hot_key_playback */

/*

 * hot_key_recording

 *

 * ...allows user to turn recording on/off.

 *

 */

{

    if (istream_replay) {

	print_string ("Playback off\n");

	replay_close ();

    } else if (ostream_record) {

	print_string ("Recording off\n");

	record_close ();

    } else {

	print_string ("Recording on\n");

	record_open ();

    }

    return FALSE;

}/* hot_key_recording */

/*

 * hot_key_seed

 *

 * ...allows user to seed the random number seed.

 *

 */

{

    print_string ("Seed random numbers\n");

    print_string ("Enter seed value (or return to randomize): ");

    seed_random (read_number ());

    return FALSE;

}/* hot_key_seed */

/*

 * hot_key_undo

 *

 * ...allows user to undo the previous turn.

 *

 */

{

    print_string ("Undo one turn\n");

    if (restore_undo ()) {

	if (h_version >= V5) {		/* for V5+ games we must */

	    store (2);			/* store 2 (for success) */

	    return TRUE;		/* and abort the input   */

	}

	if (h_version <= V3) {		/* for V3- games we must */

	    z_show_status ();		/* draw the status line  */

	    return FALSE;		/* and continue input    */

	}

    } else print_string ("No more undo information available.\n");

    return FALSE;

}/* hot_key_undo */

/*

 * hot_key_restart

 *

 * ...allows user to start a new game.

 *

 */

{

    print_string ("New game\n");

    if (read_yes_or_no ("Do you wish to restart")) {

	z_restart ();

	return TRUE;

    } else return FALSE;

}/* hot_key_restart */

/*

 * hot_key_quit

 *

 * ...allows user to exit the game.

 *

 */

{

    print_string ("Exit game\n");

    if (read_yes_or_no ("Do you wish to quit")) {

	z_quit ();

	return TRUE;

    } else return FALSE;

}/* hot_key_quit */

/*

 * handle_hot_key

 *

 * Perform the action associated with a so-called hot key. Return

 * true to abort the current input action.

 *

 */

{

    if (cwin == 0) {

	aborting = FALSE;

	print_string ("\nHot key -- ");

	switch (key) {

	    case ZC_HKEY_RECORD: aborting = hot_key_recording (); break;

	    case ZC_HKEY_PLAYBACK: aborting = hot_key_playback (); break;

	    case ZC_HKEY_SEED: aborting = hot_key_seed (); break;

	    case ZC_HKEY_UNDO: aborting = hot_key_undo (); break;

	    case ZC_HKEY_RESTART: aborting = hot_key_restart (); break;

	    case ZC_HKEY_QUIT: aborting = hot_key_quit (); break;

	    case ZC_HKEY_DEBUG: aborting = hot_key_debugging (); break;

	    case ZC_HKEY_HELP: aborting = hot_key_help (); break;

	}

	if (aborting)

	    return TRUE;

	print_string ("\nContinue input...\n");

    }

    return FALSE;

/* input.c - High level input functions

 *	Copyright (c) 1995-1997 Stefan Jokisch

 *

 * This file is part of Frotz.

 *

 * Frotz 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.

 *

 * Frotz 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.