#ifndef WH_ENIGMA_H_b0cf3ca3_
#define WH_ENIGMA_H_b0cf3ca3_

/*
 * enigma/enigma.h - global prototypes for Enigma.
 *
 * Copyright 2000 Simon Tatham. All rights reserved.
 *
 * Enigma is licensed under the MIT licence. See the file LICENCE for
 * details.
 *
 * - we are all amf -
 */

#include <setjmp.h>
#include <time.h>
#ifdef _WIN32
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>
#endif
#include "settings.h"

/* ----------------------------------------------------------------------
 * Standard useful macros.
 */
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#define lenof(array) ( sizeof((array)) / sizeof(*(array)) )

/* ----------------------------------------------------------------------
 * Data structures.
 */

/*
 * Per-level flags for the gamestate and level structures.
 */
#define LEVEL_FLIMSY_BOMBS 0x0001      /* bombs blow when hit by other bombs */
#define LEVEL_REL_PRIORITY 0x0002      /* expose priority is variable */

/*
 * First, a structure describing the state of a game between two
 * moves. (At intermediate positions within one move, there is more
 * state than this: moving objects and exposed cells are held in
 * lists. However, all of that must be cleaned up and finished
 * before the move ends, so between moves these lists are not
 * visible.)
 */
typedef struct {
    enum { PLAYING, COMPLETED, DIED, BROKEN } status;
	  int failed;
    char *leveldata;
    char *title;
    int width, height;
    int flags;
    int player_x, player_y;
    int gold_got, gold_total;
    int levnum, movenum;
    char *sequence;
    int sequence_size;
} gamestate;

/*
 * A structure describing a level.
 */
typedef struct {
    char *title;
    char *leveldata;
    int width, height;
    int flags;
} level;

/*
 * A structure describing a complete set of levels.
 */
typedef struct {
    char *title;
    const char *name;
    int nlevels;
    level **levels;
} levelset;

/*
 * A small structure describing a user's progress.
 */
typedef struct {
    int levnum;
    time_t date;
} progress;

/* ----------------------------------------------------------------------
 * Function prototypes.
 */

/*
 * Memory allocation routines, in memory.c. Create and destroy a
 * gamestate, a levelset, and a level.
 *
 * All of these can be assumed to succeed. They will bomb out with
 * longjmp if they fail.
 *
 * level_new and levelset_new create no initial data buffer within
 * the structures. These must be set later using level_setsize and
 * levelset_nlevels.
 */
extern gamestate *gamestate_new(int, int, int);
extern gamestate *gamestate_copy(gamestate *);
extern void gamestate_free(gamestate *);

extern level *level_new(void);
extern void level_setsize(level *, int, int);
extern void level_free(level *);

extern levelset *levelset_new(void);
extern void levelset_nlevels(levelset *, int);
extern void levelset_free(levelset *);

extern void *smalloc(size_t);
extern void *srealloc(void *, size_t);
extern void sfree(void *);
extern char *dupstr(char *);

/*
 * From engine.c, the make_move() function. Accepts as input a move
 * ('h', 'j', 'k' or 'l') and a gamestate. Returns a modified
 * gamestate to reflect the consequences of the move. Also
 * init_game(), which sets up a gamestate from a level.
 */
extern gamestate *make_move (gamestate *, char);
extern gamestate *init_game (level *);

/*
 * Also from engine.c, a level validator which checks a level
 * structure to ensure it contains no obvious mistakes. Returns an
 * error message in `buffer', or NULL.
 */
extern char *validate(level *, char *, int);

/*
 * From levelfile.c, the load_levels() function. Given the filename
 * stem of a level set, will load the level set into memory and
 * return a levelset structure.
 */
extern levelset *levelset_load(const char *);

/*
 * From savefile.c, routines to load and save a user's progress and
 * saved positions, plus a routine to load a move sequence for
 * replay.
 */
extern gamestate *savepos_load(levelset *, char *, int);
extern void savepos_del(levelset *, char *, int);
extern void savepos_save(levelset *, char *, int, gamestate *);
extern progress progress_load(levelset *, char *);
extern void progress_save(levelset *, char *, progress);
extern char *sequence_load(char *);
extern void sequence_save(char *, gamestate *);

/*
 * From misc.c, miscellaneous things.
 */
extern void fatal(const char *);
extern int ishdr(char *, const char *);
extern void get_user(char *, int);
extern time_t parse_date(char *);
extern void fmt_date(char *, time_t);

/*
 * From screen.c, screen handling routines.
 */
extern void screen_init(void);
extern void screen_finish(void);
extern void screen_level_init(void);
extern void screen_level_finish(void);
extern void screen_level_display(gamestate *, const char *);
extern int screen_level_getmove(int);
extern int screen_movie_getmove(void);
extern void screen_error_box(const char *);
extern char *screen_ask_movefile(int);
extern int screen_main_menu(levelset *, gamestate **, int, int);
extern int screen_saveslot_ask(char, gamestate **, int);
extern void screen_completed_game(void);

/* ----------------------------------------------------------------------
 * Global data.
 */

/*
 * A means of reporting memory allocation errors or other
 * fatalities. Will return to the main program just before
 * finalising curses, so that fatal errors don't leave the terminal
 * in a silly state. Also provided is a char * variable to leave an
 * error message in before longjmping.
 */
extern char *fatal_error_string;
extern jmp_buf fatal_error_jmp_buf;

#endif