path: root/engines/glk/adrift/scinterf.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "glk/adrift/adrift.h"
#include "glk/adrift/scprotos.h"
#include "glk/adrift/scgamest.h"
#include "common/file.h"
#include "common/system.h"
#include "common/savefile.h"

namespace Glk {
namespace Adrift {

/* Assorted definitions and constants. */
static const sc_char NEWLINE = '\n';
static const sc_char CARRIAGE_RETURN = '\r';
static const sc_char NUL = '\0';

/* Global tracing flags. */
static sc_uint if_trace_flags = 0;


/*
 * if_initialize()
 *
 * First-time runtime checks for the overall interpreter.  This function
 * tries to ensure correct compile options.
 */
static void
if_initialize (void)
{
  static sc_bool initialized = FALSE;

  /* Only do checks on the first call. */
  if (!initialized)
    {
      /* Make a few quick checks on types and type sizes. */
      if (sizeof (sc_byte) != 1 || sizeof (sc_char) != 1)
        {
          sc_error ("if_initialize: sizeof sc_byte or sc_char"
                    " is not 1, check compile options\n");
        }
      else if (sizeof (sc_uint) < 4 || sizeof (sc_int) < 4)
        {
          sc_error ("if_initialize: sizeof sc_uint or sc_int"
                    " is not at least 4, check compile options\n");
        }
      else if (sizeof (sc_uint) > 8 || sizeof (sc_int) > 8)
        {
          sc_error ("if_initialize: sizeof sc_uint or sc_int"
                    " is more than 8, check compile options\n");
        }
      else if (!((sc_uint) -1 > 0))
        {
          sc_error ("if_initialize: sc_uint appears not to be unsigned,"
                    " check compile options\n");
        }

      initialized = TRUE;
    }
}


/*
 * if_bool()
 * sc_set_trace_flags()
 * if_get_trace_flag()
 *
 * Set and retrieve tracing flags.  Setting new values propagates the new
 * tracing setting to all modules that support it.
 */
static sc_bool
if_bool (sc_uint flag)
{
  return flag ? TRUE : FALSE;
}

void
sc_set_trace_flags (sc_uint trace_flags)
{
  if_initialize ();

  /* Save the value for queries. */
  if_trace_flags = trace_flags;

  /* Propagate tracing to modules that support it. */
  parse_debug_trace (if_bool (trace_flags & SC_TRACE_PARSE));
  prop_debug_trace (if_bool (trace_flags & SC_TRACE_PROPERTIES));
  var_debug_trace (if_bool (trace_flags & SC_TRACE_VARIABLES));
  uip_debug_trace (if_bool (trace_flags & SC_TRACE_PARSER));
  lib_debug_trace (if_bool (trace_flags & SC_TRACE_LIBRARY));
  evt_debug_trace (if_bool (trace_flags & SC_TRACE_EVENTS));
  npc_debug_trace (if_bool (trace_flags & SC_TRACE_NPCS));
  obj_debug_trace (if_bool (trace_flags & SC_TRACE_OBJECTS));
  task_debug_trace (if_bool (trace_flags & SC_TRACE_TASKS));
  restr_debug_trace (if_bool (trace_flags & SC_TRACE_TASKS));
  pf_debug_trace (if_bool (trace_flags & SC_TRACE_PRINTFILTER));
}

sc_bool
if_get_trace_flag (sc_uint bitmask)
{
  return if_bool (if_trace_flags & bitmask);
}


/*
 * if_print_string_common()
 * if_print_string()
 * if_print_debug()
 * if_print_character_common()
 * if_print_character()
 * if_print_debug_character()
 * if_print_tag()
 *
 * Call OS-specific print function for the given arguments.
 */
static void
if_print_string_common (const sc_char *string,
                        void (*print_string_function) (const sc_char *))
{
  assert (string);

  if (string[0] != NUL)
    print_string_function (string);
}

void
if_print_string (const sc_char *string)
{
  if_print_string_common (string, os_print_string);
}

void
if_print_debug (const sc_char *string)
{
  if_print_string_common (string, os_print_string_debug);
}

static void
if_print_character_common (sc_char character,
                           void (*print_string_function) (const sc_char *))
{
  if (character != NUL)
    {
      sc_char buffer[2];

      buffer[0] = character;
      buffer[1] = NUL;
      print_string_function (buffer);
    }
}

void
if_print_character (sc_char character)
{
  if_print_character_common (character, os_print_string);
}

void
if_print_debug_character (sc_char character)
{
  if_print_character_common (character, os_print_string_debug);
}

void
if_print_tag (sc_int tag, const sc_char *arg)
{
  assert (arg);

  os_print_tag (tag, arg);
}


/*
 * if_read_line_common()
 * if_read_line()
 * if_read_debug()
 *
 * Call OS-specific line read function.  Clean up any read data a little
 * before returning it to the caller.
 */
static void
if_read_line_common (sc_char *buffer, sc_int length,
                     sc_bool (*read_line_function) (sc_char *, sc_int))
{
  sc_bool is_line_available;
  sc_int last;
  assert (buffer && length > 0);

  /* Loop until valid player input is available. */
  do
    {
      /* Space first with a blank line, and clear the buffer. */
      if_print_character ('\n');
      memset (buffer, NUL, length);

      is_line_available = read_line_function (buffer, length);
	  if (g_vm->shouldQuit())
		  return;
    }
  while (!is_line_available);

  /* Drop any trailing newline/return. */
  last = strlen (buffer) - 1;
  while (last >= 0
         && (buffer[last] == CARRIAGE_RETURN || buffer[last] == NEWLINE))
    buffer[last--] = NUL;
}

void
if_read_line (sc_char *buffer, sc_int length)
{
  if_read_line_common (buffer, length, os_read_line);
}

void
if_read_debug (sc_char *buffer, sc_int length)
{
  if_read_line_common (buffer, length, os_read_line_debug);
}


/*
 * if_confirm()
 *
 * Call OS-specific confirm function.
 */
sc_bool
if_confirm (sc_int type)
{
  return os_confirm (type);
}


/*
 * if_open_saved_game()
 * if_write_saved_game()
 * if_read_saved_game()
 * if_close_saved_game()
 *
 * Call OS-specific functions for saving and restoring games.
 */
void *
if_open_saved_game (sc_bool is_save)
{
  return os_open_file (is_save);
}

void
if_write_saved_game (void *opaque, const sc_byte *buffer, sc_int length)
{
  assert (buffer);

  os_write_file (opaque, buffer, length);
}

sc_int
if_read_saved_game (void *opaque, sc_byte *buffer, sc_int length)
{
  assert (buffer);

  return os_read_file (opaque, buffer, length);
}

void
if_close_saved_game (void *opaque)
{
  os_close_file (opaque);
}


/*
 * if_display_hints()
 *
 * Call OS-specific hint display function.
 */
void
if_display_hints (sc_gameref_t game)
{
  assert (gs_is_game_valid (game));

  os_display_hints ((sc_game) game);
}


/*
 * if_update_sound()
 * if_update_graphic()
 *
 * Call OS-specific sound and graphic handler functions.
 */
void
if_update_sound (const sc_char *filename,
                 sc_int sound_offset, sc_int sound_length,
                 sc_bool is_looping)
{
  if (strlen (filename) > 0)
    os_play_sound (filename, sound_offset, sound_length, is_looping);
  else
    os_stop_sound ();
}

void
if_update_graphic (const sc_char *filename,
                   sc_int graphic_offset, sc_int graphic_length)
{
  os_show_graphic (filename, graphic_offset, graphic_length);
}


/*
 * sc_scare_version()
 * sc_scare_emulation()
 *
 * Return a version string and Adrift emulation level.
 */
const sc_char *
sc_scare_version (void)
{
  if_initialize ();
  return "SCARE " SCARE_VERSION SCARE_PATCH_LEVEL;
}

sc_int
sc_scare_emulation (void)
{
  if_initialize ();
  return SCARE_EMULATION;
}


/*
 * if_file_read_callback()
 * if_file_write_callback()
 *
 * Standard FILE* reader and writer callback for constructing callback-style
 * calls from filename and stream variants.
 */
static sc_int
if_file_read_callback (void *opaque, sc_byte *buffer, sc_int length) {
  Common::SeekableReadStream *stream = (Common::SeekableReadStream *)opaque;
  sc_int bytes;

  bytes = stream->read(buffer, length);
  if (stream->err())
    sc_error ("if_file_read_callback: warning: read error\n");

  return bytes;
}

static void if_file_write_callback (void *opaque, const sc_byte *buffer, sc_int length)
{
  Common::WriteStream *stream = (Common::WriteStream *) opaque;

  stream->write(buffer, length);
  if (stream->err())
    sc_error ("if_file_write_callback: warning: write error\n");
}


/*
 * sc_game_from_filename()
 * sc_game_from_stream()
 * sc_game_from_callback()
 *
 * Called by the OS-specific layer to create a run context.  The _filename()
 * and _stream() variants are adapters for run_create().
 */
sc_game
sc_game_from_filename (const sc_char *filename) {
  Common::File *stream;
  sc_game game;

  if_initialize ();
  if (!filename)
    {
      sc_error ("sc_game_from_filename: nullptr filename\n");
      return nullptr;
    }

  stream = new Common::File();
  if (!stream->open(filename)) {
		  delete stream;
      sc_error ("sc_game_from_filename: fopen error\n");
      return nullptr;
    }

  game = run_create (if_file_read_callback, stream);
  delete stream;

  return game;
}

sc_game sc_game_from_stream (Common::SeekableReadStream *stream) {
  if_initialize ();
  if (!stream)
    {
      sc_error ("sc_game_from_stream: nullptr stream\n");
      return nullptr;
    }

  return run_create (if_file_read_callback, stream);
}

sc_game
sc_game_from_callback (sc_int (*callback) (void *, sc_byte *, sc_int),
                       void *opaque)
{
  if_initialize ();
  if (!callback)
    {
      sc_error ("sc_game_from_callback: nullptr callback\n");
      return nullptr;
    }

  return run_create (callback, opaque);
}


/*
 * if_game_error()
 *
 * Common function to verify that the game passed in to functions below
 * is a valid game.  Returns TRUE on game error, FALSE if okay.
 */
static sc_bool
if_game_error (sc_gameref_t game, const sc_char *function_name)
{
  /* Check for invalid game -- null pointer or bad magic. */
  if (!gs_is_game_valid (game))
    {
      if (game)
        sc_error ("%s: invalid game\n", function_name);
      else
        sc_error ("%s: nullptr game\n", function_name);
      return TRUE;
    }

  /* No game error. */
  return FALSE;
}


/*
 * sc_interpret_game()
 * sc_restart_game()
 * sc_save_game()
 * sc_load_game()
 * sc_undo_game_turn()
 * sc_quit_game()
 *
 * Called by the OS-specific layer to run a game loaded into a run context,
 * and to quit the interpreter on demand, if required.  sc_quit_game()
 * is implemented as a longjmp(), so never returns to the caller --
 * instead, the program behaves as if sc_interpret_game() had returned.
 * sc_load_game() will longjmp() if the restore is successful (thus
 * behaving like sc_restart_game()), but will return if the game could not
 * be restored.  sc_undo_game_turn() behaves like sc_load_game().
 */
void
sc_interpret_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_interpret_game"))
    return;

  run_interpret (game_);
}

void
sc_restart_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_restart_game"))
    return;

  run_restart (game_);
}

sc_bool
sc_save_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_save_game"))
    return FALSE;

  return run_save_prompted (game_);
}

sc_bool
sc_load_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_load_game"))
    return FALSE;

  return run_restore_prompted (game_);
}

sc_bool
sc_undo_game_turn (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_undo_game_turn"))
    return FALSE;

  return run_undo (game_);
}

void
sc_quit_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_quit_game"))
    return;

  run_quit (game_);
}


/*
 * sc_save_game_to_filename()
 * sc_save_game_to_stream()
 * sc_save_game_to_callback()
 * sc_load_game_from_filename()
 * sc_load_game_from_stream()
 * sc_load_game_from_callback()
 *
 * Low level game saving and loading functions.  The normal sc_save_game()
 * and sc_load_game() functions act exactly as the "save" and "restore"
 * game commands, in that they prompt the user for a stream to write or read.
 * These alternative forms allow the caller to directly specify the data
 * streams.
 */
sc_bool
sc_save_game_to_filename (sc_game game, const sc_char *filename)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  Common::OutSaveFile *sf;

  if (if_game_error (game_, "sc_save_game_to_filename"))
    return FALSE;

  if (!filename)
    {
      sc_error ("sc_save_game_to_filename: nullptr filename\n");
      return FALSE;
    }

  sf = g_system->getSavefileManager()->openForSaving(filename);
  if (!sf) {
      sc_error ("sc_save_game_to_filename: fopen error\n");
      return FALSE;
    }

  run_save(game_, if_file_write_callback, sf);
  sf->finalize();
  delete sf;

  return TRUE;
}

void
sc_save_game_to_stream (sc_game game, Common::SeekableReadStream *stream)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_save_game_to_stream"))
    return;

  if (!stream)
    {
      sc_error ("sc_save_game_to_stream: nullptr stream\n");
      return;
    }

  run_save (game_, if_file_write_callback, stream);
}

void
sc_save_game_to_callback (sc_game game,
                          void (*callback) (void *, const sc_byte *, sc_int),
                          void *opaque)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_save_game_to_callback"))
    return;

  if (!callback)
    {
      sc_error ("sc_save_game_to_callback: nullptr callback\n");
      return;
    }

  run_save (game_, callback, opaque);
}

sc_bool
sc_load_game_from_filename (sc_game game, const sc_char *filename)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  Common::InSaveFile *sf;
  sc_bool status;

  if (if_game_error (game_, "sc_load_game_from_filename"))
    return FALSE;

  if (!filename)
    {
      sc_error ("sc_load_game_from_filename: nullptr filename\n");
      return FALSE;
    }

  sf = g_system->getSavefileManager()->openForLoading(filename);
  if (!sf)
    {
      sc_error ("sc_load_game_from_filename: fopen error\n");
      return FALSE;
    }

  status = run_restore (game_, if_file_read_callback, sf);
  delete sf;

  return status;
}

sc_bool
sc_load_game_from_stream (sc_game game, Common::SeekableReadStream *stream)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_load_game_from_stream"))
    return FALSE;

  if (!stream)
    {
      sc_error ("sc_load_game_from_stream: nullptr stream\n");
      return FALSE;
    }

  return run_restore (game_, if_file_read_callback, stream);
}

sc_bool
sc_load_game_from_callback (sc_game game,
                            sc_int (*callback) (void *, sc_byte *, sc_int),
                            void *opaque)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_load_game_from_callback"))
    return FALSE;

  if (!callback)
    {
      sc_error ("sc_load_game_from_callback: nullptr callback\n");
      return FALSE;
    }

  return run_restore (game_, callback, opaque);
}


/*
 * sc_free_game()
 *
 * Called by the OS-specific layer to free run context memory.
 */
void
sc_free_game (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_free_game"))
    return;

  run_destroy (game_);
}


/*
 * sc_is_game_running()
 * sc_get_game_name()
 * sc_get_game_author()
 * sc_get_game_compile_date()
 * sc_get_game_turns()
 * sc_get_game_score()
 * sc_get_game_max_score()
 * sc_get_game_room ()
 * sc_get_game_status_line ()
 * sc_get_game_preferred_font ()
 * sc_get_game_bold_room_names()
 * sc_get_game_verbose()
 * sc_get_game_notify_score_change()
 * sc_has_game_completed()
 * sc_is_game_undo_available()
 *
 * Return a few attributes of a game.
 */
sc_bool
sc_is_game_running (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_is_game_running"))
    return FALSE;

  return run_is_running (game_);
}

const sc_char *
sc_get_game_name (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_name"))
    return "[invalid game]";

  run_get_attributes (game_, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr);
  return retval;
}

const sc_char *
sc_get_game_author (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_author"))
    return "[invalid game]";

  run_get_attributes (game_, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr);
  return retval;
}

const sc_char *
sc_get_game_compile_date (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_compile_date"))
    return "[invalid game]";

  run_get_attributes (game_, nullptr, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

sc_int
sc_get_game_turns (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_int retval;

  if (if_game_error (game_, "sc_get_game_turns"))
    return 0;

  run_get_attributes (game_, nullptr, nullptr, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

sc_int
sc_get_game_score (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_int retval;

  if (if_game_error (game_, "sc_get_game_score"))
    return 0;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

sc_int
sc_get_game_max_score (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_int retval;

  if (if_game_error (game_, "sc_get_game_max_score"))
    return 0;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

const sc_char *
sc_get_game_room (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_room"))
    return "[invalid game]";

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &retval,
                      nullptr, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

const sc_char *
sc_get_game_status_line (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_status_line"))
    return "[invalid game]";

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      &retval, nullptr, nullptr, nullptr, nullptr);
  return retval;
}

const sc_char *
sc_get_game_preferred_font (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_char *retval;

  if (if_game_error (game_, "sc_get_game_preferred_font"))
    return "[invalid game]";

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, &retval, nullptr, nullptr, nullptr);
  return retval;
}

sc_bool
sc_get_game_bold_room_names (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool retval;

  if (if_game_error (game_, "sc_get_game_bold_room_names"))
    return FALSE;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, &retval, nullptr, nullptr);
  return retval;
}

sc_bool
sc_get_game_verbose (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool retval;

  if (if_game_error (game_, "sc_get_game_verbose"))
    return FALSE;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, nullptr, &retval, nullptr);
  return retval;
}

sc_bool
sc_get_game_notify_score_change (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool retval;

  if (if_game_error (game_, "sc_get_game_notify_score_change"))
    return FALSE;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, nullptr, nullptr, &retval);
  return retval;
}

sc_bool
sc_has_game_completed (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_has_game_completed"))
    return FALSE;

  return run_has_completed (game_);
}

sc_bool
sc_is_game_undo_available (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_is_game_undo_available"))
    return FALSE;

  return run_is_undo_available (game_);
}


/*
 * sc_set_game_bold_room_names()
 * sc_set_game_verbose()
 * sc_set_game_notify_score_change()
 *
 * Set a few attributes of a game.
 */
void
sc_set_game_bold_room_names (sc_game game, sc_bool flag)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool bold, verbose, notify;

  if (if_game_error (game_, "sc_set_game_bold_room_names"))
    return;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, &bold, &verbose, &notify);
  run_set_attributes (game_, flag, verbose, notify);
}

void
sc_set_game_verbose (sc_game game, sc_bool flag)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool bold, verbose, notify;

  if (if_game_error (game_, "sc_set_game_verbose"))
    return;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, &bold, &verbose, &notify);
  run_set_attributes (game_, bold, flag, notify);
}

void
sc_set_game_notify_score_change (sc_game game, sc_bool flag)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  sc_bool bold, verbose, notify;

  if (if_game_error (game_, "sc_set_game_notify_score_change"))
    return;

  run_get_attributes (game_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                      nullptr, nullptr, &bold, &verbose, &notify);
  run_set_attributes (game_, bold, verbose, flag);
}


/*
 * sc_does_game_use_sounds()
 * sc_does_game_use_graphics()
 *
 * Indicate the game's use of resources.
 */
sc_bool
sc_does_game_use_sounds (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_does_game_use_sounds"))
    return FALSE;

  return res_has_sound (game_);
}

sc_bool
sc_does_game_use_graphics (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_does_game_use_graphics"))
    return FALSE;

  return res_has_graphics (game_);
}


/*
 * sc_get_first_game_hint()
 * sc_get_next_game_hint()
 * sc_get_game_hint_question()
 * sc_get_game_subtle_hint()
 * sc_get_game_sledgehammer_hint()
 *
 * Iterate currently available hints, and return strings for a hint.
 */
sc_game_hint
sc_get_first_game_hint (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_get_first_game_hint"))
    return nullptr;

  return run_hint_iterate (game_, nullptr);
}

sc_game_hint
sc_get_next_game_hint (sc_game game, sc_game_hint hint)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_hintref_t hint_ = (const sc_hintref_t)hint;

  if (if_game_error (game_, "sc_get_next_game_hint"))
    return nullptr;
  if (!hint_)
    {
      sc_error ("sc_get_next_game_hint: nullptr hint\n");
      return nullptr;
    }

  return run_hint_iterate (game_, hint_);
}

const sc_char *
sc_get_game_hint_question (sc_game game, sc_game_hint hint)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_hintref_t hint_ = (const sc_hintref_t)hint;

  if (if_game_error (game_, "sc_get_game_hint_question"))
    return nullptr;
  if (!hint_)
    {
      sc_error ("sc_get_game_hint_question: nullptr hint\n");
      return nullptr;
    }

  return run_get_hint_question (game_, hint_);
}

const sc_char *
sc_get_game_subtle_hint (sc_game game, sc_game_hint hint)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_hintref_t hint_ = (const sc_hintref_t)hint;

  if (if_game_error (game_, "sc_get_game_subtle_hint"))
    return nullptr;
  if (!hint_)
    {
      sc_error ("sc_get_game_subtle_hint: nullptr hint\n");
      return nullptr;
    }

  return run_get_subtle_hint (game_, hint_);
}

const sc_char *
sc_get_game_unsubtle_hint (sc_game game, sc_game_hint hint)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;
  const sc_hintref_t hint_ = (const sc_hintref_t)hint;

  if (if_game_error (game_, "sc_get_game_unsubtle_hint"))
    return nullptr;
  if (!hint_)
    {
      sc_error ("sc_get_game_unsubtle_hint: nullptr hint\n");
      return nullptr;
    }

  return run_get_unsubtle_hint (game_, hint_);
}


/*
 * sc_set_game_debugger_enabled()
 * sc_is_game_debugger_enabled()
 * sc_run_game_debugger_command()
 *
 * Enable, disable, and query game debugging, and run a single debug command.
 */
void
sc_set_game_debugger_enabled (sc_game game, sc_bool flag)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_set_game_debugger_enabled"))
    return;

  debug_set_enabled (game_, flag);
}

sc_bool
sc_get_game_debugger_enabled (sc_game game)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_get_game_debugger_enabled"))
    return FALSE;

  return debug_get_enabled (game_);
}

sc_bool
sc_run_game_debugger_command (sc_game game, const sc_char *debug_command)
{
  const sc_gameref_t game_ = (const sc_gameref_t)game;

  if (if_game_error (game_, "sc_run_game_debugger_command"))
    return FALSE;

  return debug_run_command (game_, debug_command);
}


/*
 * sc_set_locale()
 * sc_get_locale()
 *
 * Set the interpreter locale, and get the currently set locale.
 */
sc_bool
sc_set_locale (const sc_char *name)
{
  if (!name)
    {
      sc_error ("sc_set_locale: nullptr name\n");
      return FALSE;
    }

  return loc_set_locale (name);
}

const sc_char *
sc_get_locale (void)
{
  return loc_get_locale ();
}


/*
 * sc_set_portable_random()
 * sc_reseed_random_sequence()
 *
 * Turn portable random number generation on and off, and supply a new seed
 * for random number generators.
 */
void
sc_set_portable_random (sc_bool flag)
{
  if (flag)
    sc_set_congruential_random ();
  else
    sc_set_platform_random ();
}

void
sc_reseed_random_sequence (sc_uint new_seed)
{
  if (new_seed == 0)
    {
      sc_error ("sc_reseed_random_sequence: new_seed may not be 0\n");
      return;
    }

  sc_seed_random (new_seed);
}

} // End of namespace Adrift
} // End of namespace Glk