noble.h

Go to the documentation of this file.

/****************************************************************

 noble.h

 =============================================================

 Copyright 1996-2014 Tom Barbalet. All rights reserved.

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use,
 copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:

 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.

 This software and Noble Ape are a continuing work of Tom Barbalet,
 begun on 13 June 1996. No apes or cats were harmed in the writing
 of this software.

 ****************************************************************/

#ifndef _NOBLEAPE_NOBLE_H_
#define _NOBLEAPE_NOBLE_H_
/*      Variable Definitions */

#define  SCRIPT_DEBUG             /* Add all the runtime debug */
#undef   COMMAND_LINE_DEBUG       /* Sends the debug output as printf output - added through command line build */
#undef   ROUGH_CODE_OUT           /* printf outputs the interpret stream in character number format */

#ifdef OVERWRITE_THREADED

#else

#ifdef NOBLE_IOS
    #undef  EXECUTE_THREADED
#else
    #define  EXECUTE_THREADED
#endif

#endif

#ifdef COMMAND_LINE_EXPLICIT

#define  NOBLE_APE_ASSERT

#else

#undef  NOBLE_APE_ASSERT

#endif

#define SHORT_VERSION_NAME               "Noble Ape 0.699 "
#define FULL_DATE                                __DATE__

#define VERSION_NUMBER               699
#define COPYRIGHT_DATE               "Copyright 1996 - 2014 "

#define FULL_VERSION_COPYRIGHT "Copyright Tom Barbalet, 1996-2014."

#define NOBLE_APE_SIGNATURE                 (('N'<< 8) | 'A')
#define NOBLE_WARFARE_SIGNATURE         (('N'<< 8) | 'W')

#define  COPYRIGHT_NAME             "Tom Barbalet. "
#define  COPYRIGHT_FOLLOW               "All rights reserved."

#define PACKED_DATA_BLOCK   (32*32*32*2)

typedef double  n_double;

#define TWO_PI ((n_double)(6.2831853071795864769252867665590057683943))

#define SINE_MAXIMUM (26880)

typedef char *          n_string;

typedef const char *    n_constant_string;

#define STRING_BLOCK_SIZE (2048)

typedef char       n_string_block[STRING_BLOCK_SIZE];

typedef unsigned char   n_byte;
typedef unsigned short  n_byte2;

typedef unsigned int    n_byte4;
typedef int                             n_c_int;

#ifndef _WIN64

typedef unsigned long   n_uint;

typedef long                    n_int;

#else

typedef unsigned long long      n_uint;
typedef long long                       n_int;

#endif

typedef short   n_audio;


#ifdef NOBLE_APE_ASSERT

#define NA_ASSERT(test, message) if(!(test))io_assert(message, __FILE__, __LINE__)

void io_assert(n_string message, n_string file_loc, n_int line);

#else

#define NA_ASSERT(test, message) /* test message */

#endif

#define AUDIO_FFT_MAX_BITS      (15)
#define AUDIO_FFT_MAX_BUFFER    (1<<AUDIO_FFT_MAX_BITS)

void   audio_fft(n_byte inverse, n_uint power_sample);
void   audio_clear_buffers(n_uint length);
void   audio_clear_output(n_audio * audio, n_uint length);

void   audio_equal_output(n_audio * audio, n_uint length);

void   audio_multiply_output(n_audio * audio, n_uint length);
void   audio_set_frequency(n_uint entry, n_uint value);

typedef struct
{
    n_byte2 signature;
    n_byte2 version;
} n_version;

typedef struct
{
    n_int x;
    n_int y;
} n_vect2;

typedef struct
{
    n_byte4  date;
    n_byte2  location[2];
    n_byte2  time;
}
n_spacetime;

typedef struct
{
    n_byte  characters[7];
    n_byte  incl_kind;
    n_uint  number_entries;
    n_uint  start_location;
    const n_string what_is_it;
} noble_file_entry;

#define POPULATED(ch) ((ch[0] != 0) || (ch[1] != 0) || (ch[2] != 0) || (ch[3] != 0) || (ch[4] != 0) || (ch[5] != 0))

/* include externally, if needed */

#define FILE_COPYRIGHT      0x00

enum file_element_type
{
    FILE_TYPE_BYTE              = 0x01,
    FILE_TYPE_BYTE2             = 0x02,
    FILE_TYPE_BYTE_EXT  = 0x03,
    FILE_TYPE_PACKED    = 0x05,
    FILE_TYPE_BYTE4     = 0x06
};

#define FILE_INCL(num)      ((num) & 0xf0)
#define FILE_KIND(num)      ((num) & 0x0f)

#define FILE_EOF                                0x0100

#define ASCII_NUMBER(val)               (((val) >= '0') && ((val) <= '9'))
#define ASCII_LOWERCASE(val)    (((val) >= 'a') && ((val) <= 'z'))
#define ASCII_UPPERCASE(val)    (((val) >= 'A') && ((val) <= 'Z'))

#define FILE_OKAY                                 0x0000
#define FILE_ERROR                                (-1)

typedef n_string (n_console_input)(n_string value, n_int length);

typedef void (n_console_output)(n_constant_string value);

typedef n_byte (n_pixel)(n_int px, n_int py, n_int dx, n_int dy, void * information);

typedef n_int (n_memory_location)(n_int px, n_int py);

typedef n_byte2 (n_patch)(n_byte2 * local);

typedef n_int (n_console)(void * ptr, n_string response, n_console_output output_function);

typedef n_int (n_file_in)(n_byte * buff, n_uint len);

typedef n_byte * (n_file_out)(n_uint * len);

typedef struct
{
    n_console * function;
    n_string    command;
    n_string    addition;
    n_string    help_information;
} noble_console_command;

typedef struct
{
    n_pixel * pixel_draw;
    void        * information;
} n_join;

typedef struct
{
    n_byte      * screen;
    n_byte      * background;
} n_background8;

typedef struct
{
    n_byte  * screen;
    n_byte        color;
} n_color8;

typedef struct
{
    n_uint      size;
    n_uint      location;
    n_byte      *data;
} n_file;

typedef void (n_file_specific)(n_string string, n_byte * reference);

typedef struct
{
    void * data;
    n_uint expected_bytes;
    n_uint hash;
    void * next;
} n_file_chain;

#define NEW_SD_MULTIPLE                 26880

enum window_num
{
    NUM_VIEW    = (0),
    NUM_TERRAIN = (1)
#ifndef GRAPHLESS_GUI
   ,NUM_GRAPH   = (2)
#endif
};

/* maximum bytes in a braincode program */
#define BRAINCODE_SIZE                    128

/* number of probes which can be applied to the brain */
#define BRAINCODE_PROBES                  (BRAINCODE_SIZE>>3)

#define BRAINCODE_PSPACE_REGISTERS         3
/* maximum frequency of a brain probe */
#define BRAINCODE_MAX_FREQUENCY            16

/* number of bytes per instruction */
#define BRAINCODE_BYTES_PER_INSTRUCTION    3

/* number of instructions which a MVB copies */
#define BRAINCODE_BLOCK_COPY               16

#define BRAINCODE_MAX_ADDRESS              (BRAINCODE_SIZE*2)
#define BRAINCODE_ADDRESS(i)               ((i) % BRAINCODE_MAX_ADDRESS)

enum braincode_locations
{
    BRAINCODE_EXTERNAL = 0,
    BRAINCODE_INTERNAL
};

/* instruction codes */

enum BRAINCODE_COMMANDS
{
    /* data */
    BRAINCODE_DAT0 = 0,
    BRAINCODE_DAT1,
    
    /* operators */
    BRAINCODE_ADD,
    BRAINCODE_SUB,
    BRAINCODE_MUL,
    BRAINCODE_DIV,
    BRAINCODE_MOD,
    BRAINCODE_MVB,
    BRAINCODE_MOV,
    BRAINCODE_JMP,
    BRAINCODE_CTR,
    BRAINCODE_SWP,
    BRAINCODE_INV,
    BRAINCODE_STP,
    BRAINCODE_LTP,
    
    /* conditionals */
    BRAINCODE_JMZ,
    BRAINCODE_JMN,
    BRAINCODE_DJN,
    BRAINCODE_AND,
    BRAINCODE_OR,
    BRAINCODE_SEQ,
    BRAINCODE_SNE,
    BRAINCODE_SLT,
    
    /* sensors */
    BRAINCODE_SEN,
    BRAINCODE_SEN2,
    BRAINCODE_SEN3,
    
    /* actuators */
    BRAINCODE_ACT,
    BRAINCODE_ACT2,
    BRAINCODE_ACT3,
    BRAINCODE_ANE,
    
    BRAINCODE_INSTRUCTIONS
};

#ifndef GRAPHLESS_GUI

enum graph_commands
{
    GC_CLEAR_BRAINCODE = -1,

    GC_IDEOSPHERE = 0,
    GC_BRAINCODE,
    GC_GENEPOOL,
    GC_HONOR,
    GC_PATHOGENS,
    GC_RELATIONSHIPS,
    GC_PREFERENCES,
    GC_PHASESPACE,
    GC_SOCIALSIM,
    GC_MEET_PLACES,
    GC_VASCULAR
};

#endif

typedef enum
{
    WEATHER_SEVEN_ERROR = -1,
    WEATHER_SEVEN_SUNNY_DAY = 0,
    WEATHER_SEVEN_CLOUDY_DAY = 1,
    WEATHER_SEVEN_RAINY_DAY = 2,
    WEATHER_SEVEN_CLEAR_NIGHT = 3,
    WEATHER_SEVEN_CLOUDY_NIGHT = 4,
    WEATHER_SEVEN_RAINY_NIGHT = 5,
    WEATHER_SEVEN_DAWN_DUSK = 6
} weather_values;

enum window_information
{
    TERRAIN_WINDOW_WIDTH                = (2048),
    TERRAIN_WINDOW_HEIGHT       = (1536),
    TERRAIN_WINDOW_AREA                 = (TERRAIN_WINDOW_WIDTH * TERRAIN_WINDOW_HEIGHT)
#ifndef GRAPHLESS_GUI
   ,GRAPH_WINDOW_WIDTH_BITS     = 9,
    GRAPH_WINDOW_WIDTH              = (1<<GRAPH_WINDOW_WIDTH_BITS),
    GRAPH_WINDOW_HEIGHT         = (512),
    GRAPH_WINDOW_AREA                   = (GRAPH_WINDOW_WIDTH * GRAPH_WINDOW_HEIGHT * 3)
#endif
};

typedef enum
{
    KIND_LOAD_FILE = 0,
    KIND_NEW_SIMULATION,
    KIND_START_UP,
    KIND_MEMORY_SETUP
} KIND_OF_USE;

typedef enum
{
    AE_NO_ERROR = -1,

    AE_UNKNOWN_ERROR,
    AE_NUMBER_EXPECTED,
    AE_NUMBER_OUT_OF_RANGE,
    AE_MAXIMUM_NUMBERS_REACHED,
    AE_MAXIMUM_SCRIPT_SIZE_REACHED,

    AE_MAXIMUM_VARIABLES_REACHED,
    AE_UNKNOWN_SYNTAX_PARSER_BUFFER,
    AE_UNKNOWN_SYNTAX_PARSER_CONVERT,

    AE_SELECTED_ENTITY_OUT_OF_RANGE,

    AE_COORDINATES_OUT_OF_RANGE,
    AE_VALUE_OUT_OF_RANGE,

    AE_TOO_MANY_CLOSE_BRACES,
    AE_MAXIMUM_BRACES_REACHED,
    AE_FIRST_VALUE_FAILED,
    AE_SECOND_VALUE_FAILED,
    AE_UNKNOWN_SYNTAX_MISSING_EQUALS,
    AE_UNKNOWN_SYNTAX_NO_COMMAND,
    AE_WRONG_END,

    AE_LINE_START_INCORRECT,
    AE_OUTPUT_SET_AS_INPUT_VARIABLE,
    AE_IF_WHILE_NOT_FOLLOWED_BY_BRACKET,
    AE_FUNCTION_ISNT_VARIABLE,
    AE_NON_FUNCTION_APPLIED,
    AE_FUNCTION_DEFINED_PRIOR,
    AE_FUNCTION_OUT_OF_RANGE,
    AE_WITHOUT_SEMICOLON,
    AE_WITHOUT_OPEN_BRACE,
    AE_FUNCTION_SETTING_FAILED,
    AE_ERROR_STARTING_MAIN,
    AE_CODE_AFTER_MAIN,
    AE_NO_CLOSE_BRACE_TO_END_OF_FILE,
    AE_CODE_OUTSIDE_FUNCTION,
    AE_INPUT_VARIABLE_WITHOUT_EQUALS,
    AE_ASSIGN_VALUE_FAILED,
    AE_UNKNOWN_SYNTAX_FROM_INTERPRET,
    AE_NO_MAIN_CODE,

    AE_NUMBER_ERRORS
} AE_ENUM;

typedef struct
{
    AE_ENUM  enum_value;
    n_constant_string error_string;
    n_constant_string help_string;
} n_ae_error;

static const n_ae_error apescript_errors[]=
{
    {AE_UNKNOWN_ERROR,                     "Unknown error",                    "Please contact tom at nobleape dot com"},
    {AE_NUMBER_EXPECTED,                   "Number expected",                  "A non-numeric character is included in a number string."},
    {AE_NUMBER_OUT_OF_RANGE,               "Number out of range",              "Number does not fit in the range"},
    {AE_MAXIMUM_NUMBERS_REACHED,           "Maximum numbers reached",          "Please contact tom at nobleape dot com"},
    {AE_MAXIMUM_SCRIPT_SIZE_REACHED,       "Maximum script size reached",      "Please contact tom at nobleape dot com"},
    {AE_MAXIMUM_VARIABLES_REACHED,         "Maximum variables reached",        "Please contact tom at nobleape dot com"},
    {AE_UNKNOWN_SYNTAX_PARSER_BUFFER,      "Unknown syntax (parser buffer)",   "Syntax is incorrect"},
    {AE_UNKNOWN_SYNTAX_PARSER_CONVERT,     "Unknown syntax (parser convert)",  "Syntax is incorrect"},

    {AE_SELECTED_ENTITY_OUT_OF_RANGE,      "Selected entity out of range",     "Selected entity is outside the bounds of the number of entities."},
    {AE_COORDINATES_OUT_OF_RANGE,          "Coordinates out of range",         "Coordinates outside the prescribed range."},
    {AE_VALUE_OUT_OF_RANGE,                "Value out of range",               "Value outside the presecribed range."},

    {AE_TOO_MANY_CLOSE_BRACES,             "Too many }",                       "You have closed too many braces. Go back to the code and see if there is an erroneous additional } in the code."},
    {AE_MAXIMUM_BRACES_REACHED,            "Maximum braces reached",           "Please contact tom at nobleape dot com"},
    {AE_FIRST_VALUE_FAILED,                "First value failed",               "Something is wrong with the first value of an equality, if or while operation. It could be the first and only value in this function."},
    {AE_SECOND_VALUE_FAILED,               "Second value failed",              "Something is wrong with the second number/variable value of an equality, if or while operation."},
    {AE_UNKNOWN_SYNTAX_MISSING_EQUALS,     "Unknown syntax (missing =)",       "Syntax is incorrect"},
    {AE_UNKNOWN_SYNTAX_NO_COMMAND,         "Unknown syntax (no command)",      "Syntax is incorrect"},
    {AE_WRONG_END,                         "Wrong end",                        "A bracket or colon was expected but not found."},

    {AE_LINE_START_INCORRECT,              "Line start incorrect",             "A line of code begins incorrectly. It could start with a number or an operator when if/while or a variable was expected."},
    {AE_OUTPUT_SET_AS_INPUT_VARIABLE,      "Output set as input variable",     "An output only variable is attempting to be set."},
    {AE_IF_WHILE_NOT_FOLLOWED_BY_BRACKET,  "if/while not followed by {",       "All if/while statements require a bracket following the if/while (allowing for any amount of whitespace too)."},
    {AE_FUNCTION_ISNT_VARIABLE,            "Function isn't variable",          "Function must not be a special term."},
    {AE_NON_FUNCTION_APPLIED,              "Non-function applied",             "Expecting a function."},
    {AE_FUNCTION_DEFINED_PRIOR,            "Function defined prior",           "Single function definition only."},
    {AE_FUNCTION_OUT_OF_RANGE,             "Function out of range",            "Function defined outside the range of the code presented."},
    {AE_WITHOUT_SEMICOLON,                 "Without ;",                        "Semi-colon required."},
    {AE_WITHOUT_OPEN_BRACE,                "Without {",                        "All if/while statements expect what is executed through the bracket enclosed statement being correct to be followed by inclusive braces { }. There is no single line if or while statements without { } in ApeScript."},

    {AE_FUNCTION_SETTING_FAILED,           "Function setting failed",          "Function could not be set."},
    {AE_ERROR_STARTING_MAIN,               "Error starting main",              "Main could not be started."},
    {AE_CODE_AFTER_MAIN,                   "Code after main",                  "All the code in ApeScript must exist before the end of main."},
    {AE_NO_CLOSE_BRACE_TO_END_OF_FILE,     "No } to end of file",              "Based on the final main function it is expected that the last meaningful character will be }."},
    {AE_CODE_OUTSIDE_FUNCTION,             "Code outside function",            "All code in ApeScript needs to exist within functions."},
    {AE_INPUT_VARIABLE_WITHOUT_EQUALS,     "Input variable without equals",    "All variables set require an equals following the variable."},
    {AE_ASSIGN_VALUE_FAILED,               "Assign value failed",              "Something is wrong with the variable set by an equality."},
    {AE_UNKNOWN_SYNTAX_FROM_INTERPRET,     "Unknown syntax (from interpret)",  "Syntax is incorrect"},
    {AE_NO_MAIN_CODE,                      "No main code",                     "ApeScript requires a main function."},

    {AE_NO_ERROR, 0L, 0L}
};

extern n_int draw_error(n_constant_string error_text, n_constant_string location, n_int line_number);

/* "---1---2---3---4---5---6---7--" */ /* length of the errors */

#define SHOW_ERROR(val) (draw_error(val, __FILE__, __LINE__))

#define IO_LOWER_CHAR(value)   if(ASCII_UPPERCASE(value)) (value) += 'a' - 'A'


typedef n_int (execute_function)(void * general_data, void * read_data, void * write_data);

void  execute_add(execute_function function, void * general_data, void * read_data, void * write_data);

void  execute_group(execute_function * function, void * general_data, void * read_data, n_int count, n_int size);

void  execute_init(void);

void  execute_close(void);

void  execute_complete_added(void);

void  execute_threads(n_int value);
n_int execute_threads_value(void);
n_int execute_toggle(n_int toggle);

void  vect2_byte2(n_vect2 * converter, n_byte2 * input);
void  vect2_add(n_vect2 * equals, n_vect2 * initial, n_vect2 * second);
void  vect2_center(n_vect2 * center, n_vect2 * initial, n_vect2 * second);

void  vect2_subtract(n_vect2 * equals, n_vect2 * initial, n_vect2 * second);
void  vect2_multiplier(
    n_vect2 * equals, n_vect2 * initial,
    n_vect2 * second, n_int multiplier, n_int divisor);
void  vect2_d(
    n_vect2 * initial, n_vect2 * second,
    n_int multiplier, n_int divisor);
n_int vect2_dot(
    n_vect2 * initial, n_vect2 * second,
    n_int multiplier, n_int divisor);
void vect2_rotate90(n_vect2 * rotation);
void vect2_direction(n_vect2 * initial, n_int direction, n_int divisor);
void vect2_offset(n_vect2 * initial, n_int dx, n_int dy);
void vect2_back_byte2(n_vect2 * converter, n_byte2 * output);
void vect2_copy(n_vect2 * to, n_vect2 * from);
void vect2_populate(n_vect2 * value, n_int x, n_int y);

void vect2_rotation(n_vect2 * location, n_vect2 * rotation);

n_int vect2_nonzero(n_vect2 * nonzero);

n_vect2 * vect2_min_max_init(void);
void vect2_min_max(n_vect2 * points, n_int number, n_vect2 * maxmin);

n_byte * math_general_allocation(n_byte * bc0, n_byte * bc1, n_int i);

void math_general_execution(n_int instruction, n_int is_constant0, n_int is_constant1,
                            n_byte * addr0, n_byte * addr1, n_int value0, n_int * i,
                            n_int is_const0, n_int is_const1,
                            n_byte * pspace,
                            n_byte **maddr0, n_byte **maddr1,
                            n_byte *bc0, n_byte *bc1,
                            n_int braincode_min_loop);

n_byte4 math_hash_fnv1(n_constant_string key);
n_uint   math_hash(n_byte * values, n_uint length);

void    math_bilinear_8_times(n_byte * side512, n_byte * data, n_byte double_spread);

n_uint  math_root(n_uint squ);
n_byte  math_turn_towards(n_vect2 * p, n_byte fac, n_byte turn);
n_byte2 math_random(n_byte2 * local);
void    math_random3(n_byte2 * local);
n_byte  math_join(n_int sx, n_int sy, n_int dx, n_int dy, n_join * draw);
n_int   math_spread_byte(n_byte val);
void    math_pack(n_int size, n_byte value, n_byte * alloc1, n_byte *alloc2);
n_int   math_memory_location(n_int px, n_int py);
void    math_patch(n_byte * local_map,
                n_memory_location * mem_func,
                n_patch * func, n_byte2 * arg,
                n_int refine);
void   math_round(n_byte * local_map, n_byte * scratch,
                n_memory_location * mem_func);

void   math_round_smarter(n_byte * local_map, n_byte * scratch,
                   n_memory_location * mem_func);

n_int  math_sine(n_int direction, n_int divisor);

n_byte math_join_vect2(n_int sx, n_int sy, n_vect2 * vect, n_join * draw);
n_byte math_line_vect(n_vect2 * point1, n_vect2 * point2, n_join * draw);
n_byte math_line(n_int x1, n_int y1, n_int x2, n_int y2, n_join * draw);

void       io_entry_execution(n_int argc, n_string * argv);
void       io_command_line_execution_set(void);
n_int      io_command_line_execution(void);

void       io_lower(n_string value, n_int length);
void       io_whitespace(n_file * input);
void       io_audit_file(const noble_file_entry * format, n_byte section_to_audit);
void       io_search_file_format(const noble_file_entry * format, n_string compare);
void       io_string_write(n_string dest, n_string insert, n_int * pos);
n_int      io_read_bin(n_file * fil, n_byte * local_byte);
n_int      io_file_write(n_file * fil, n_byte byte);
void       io_file_reused(n_file * fil);
n_int      io_write(n_file * fil, n_constant_string ch, n_byte new_line);
n_int      io_writenumber(n_file * fil, n_int loc_val, n_uint numer, n_uint denom);
n_int      io_length(n_string value, n_int max);
n_int      io_find(n_string check, n_int from, n_int max, n_string value_find, n_int value_find_length);
n_int      io_read_buff(n_file * fil, n_byte * data, const noble_file_entry * commands);
n_int      io_write_buff(n_file * fil, void * data, const noble_file_entry * commands, n_byte command_num, n_file_specific * func);
n_int      io_write_csv(n_file * fil, n_byte * data, const noble_file_entry * commands, n_byte command_num, n_byte initial) ;
void       io_copy(n_byte * from, n_byte * to, n_uint number);
void *     io_new(n_uint bytes);
void       io_free(void ** ptr);
void *     io_new_range(n_uint memory_min, n_uint *memory_allocated);
n_file *   io_file_new(void);
void       io_file_free(n_file ** file);

n_int      io_number(n_string number_string, n_int * actual_value, n_int * decimal_divisor);

void       audio_aiff_header(void * fptr, n_uint total_samples);

void       audio_aiff_body(void * fptr, n_audio *samples, n_uint number_samples);

n_int      io_quit(void * ptr, n_string response, n_console_output output_function);
n_int      io_help(void * ptr, n_string response, n_console_output output_function);
n_string   io_console_entry_clean(n_string string, n_int length);
n_string   io_console_entry(n_string string, n_int length);
void       io_console_out(n_constant_string value);
n_int      io_console(void * ptr, noble_console_command * commands, n_console_input input_function, n_console_output output_function);
void       io_erase(n_byte * buf_offscr, n_uint nestop);
n_int      io_disk_read(n_file * local_file, n_string file_name);
n_int      io_disk_write(n_file * local_file, n_string file_name);
n_int      io_disk_check(n_constant_string file_name);
n_string * io_tab_delimit_to_n_string_ptr(n_file * tab_file, n_int * size_value, n_int * row_value);

void       io_three_string_combination(n_string output, n_string first, n_string second, n_string third, n_int count);
void       io_time_to_string(n_string value, n_int minutes, n_int days);
n_int      io_read_byte4(n_file * fil, n_uint * actual_value, n_byte * final_char);
n_int      io_writenum(n_file * fil, n_int loc_val, n_byte ekind, n_byte new_line);
n_int      io_command(n_file * fil, const noble_file_entry * commands);
n_int      io_read_data(n_file * fil, n_byte2 command, n_byte * data_read);
void       io_help_line(noble_console_command * specific, n_console_output output_function);

void       io_console_quit(void);

void       io_output_contents(n_file * file);

n_file * io_file_ready(n_int entry, n_file * file);

void io_file_cleanup(n_int * entry, n_file ** file);

void io_file_writeon(n_int * entry, n_file ** file, n_byte blocked_write);

void io_file_writeoff(n_int * entry, n_file * file);

void io_file_string(n_int entry, n_file * file, n_constant_string string);

void io_offset(n_byte * start, n_byte * point, n_string text);

n_int io_find_size_data(noble_file_entry * commands);

void compress_compress(n_file *input, n_file *output);
void compress_expand(n_file *input,   n_file *output);

#ifdef NOBLE_IOS

#define MAP_BITS                      (8)

#else

#define MAP_BITS                      (9)

#endif

#define MAP_DIMENSION                 (1<<(MAP_BITS))
#define MAP_AREA                      (1<<(2*MAP_BITS))

#define APESPACE_TO_MAPSPACE(num)     ((num)>>6)

#define HI_RES_MAP_BITS               (MAP_BITS+3)

#define HI_RES_MAP_DIMENSION          (1<<(HI_RES_MAP_BITS))
#define HI_RES_MAP_AREA               (1<<(2*HI_RES_MAP_BITS))

#define APESPACE_TO_HR_MAPSPACE(num)  ((num)>>3)

#define MAPSPACE_TO_APESPACE(num)     ((num)<<6)

#define MAP_APE_RESOLUTION_SIZE       (MAPSPACE_TO_APESPACE(MAP_DIMENSION))
#define APESPACE_BOUNDS               ((MAP_APE_RESOLUTION_SIZE)-1)

#define APESPACE_CONFINED(num)        (n_byte2)((num)>APESPACE_BOUNDS ? APESPACE_BOUNDS : ((num)<0 ? 0 : (num)))
#define APESPACE_WRAP(num)            (n_byte2)((num + APESPACE_BOUNDS)&(APESPACE_BOUNDS-1))

#define LAND_TILE_EDGE                 (256)
#define POSITIVE_LAND_COORD(num)       ((num+(3*MAP_DIMENSION))&(MAP_DIMENSION-1))
#define POSITIVE_LAND_COORD_HIRES(num) ((num+(3*HI_RES_MAP_DIMENSION))&(HI_RES_MAP_DIMENSION-1))
#define NUMBER_LAND_TILES              (MAP_DIMENSION/LAND_TILE_EDGE)
#define WEATHER_TO_MAPSPACE(num)       ((num)*2)

#define LAND_DITHER(x,y,z)             (((x+y+z)&15)-(((x&y)|z)&7)-((x|(y&z))&7))

#ifdef GRAPHLESS_GUI

#define OFFSCREENSIZE                  (MAP_AREA + TERRAIN_WINDOW_AREA)

#else

#define OFFSCREENSIZE                  (MAP_AREA + TERRAIN_WINDOW_AREA + GRAPH_WINDOW_AREA)

#endif

#define WEATHER_CLOUD           (32768)
#define WEATHER_RAIN            (98304)

#define TIME_HOUR_MINUTES           (60)
#define TIME_DAY_MINUTES            (TIME_HOUR_MINUTES * 24)
#define TIME_MONTH_MINUTES          (TIME_DAY_MINUTES * 28)
#define TIME_YEAR_MINUTES           (TIME_MONTH_MINUTES * 13)
#define TIME_YEAR_DAYS              (7 * 52)                            /*364 also = 13 * 28 */
#define TIME_CENTURY_DAYS           (TIME_YEAR_DAYS * 100)

#define LUNAR_ORBIT_MINS            39312

#define WATER_TEST(pz,w)            ((pz)<(w))

#define WATER_MAP                     128

#define TIDE_AMPLITUDE_LUNAR  8
#define TIDE_AMPLITUDE_SOLAR  2

#define TIDE_MAX              (WATER_MAP + TIDE_AMPLITUDE_LUNAR + TIDE_AMPLITUDE_SOLAR)

/* Night/Day definitions */
#define IS_NIGHT(num)           ((((num)>>5) <  (11))||(((num)>>5) >  (36)))
#define IS_DAWNDUSK(num)        ((((num)>>5) == (11))||(((num)>>5) == (36)))

#define NIGHT_END_POINT     (256)
#define DAWN_END_POINT      (384)
#define DAY_END_POINT       (1152)
#define DUSK_END_POINT      (1184)

#define MAX_MODIFIED_TIME   (238)

#define NIGHT_TIME_DIVISION(time)     ((time)>>4)
#define DAWN_DUSK_TIME_DIVISION(time) ((time)>>3)
#define DAY_TIME_DIVISION(time)       ((time)>>2)

/*
 Night 1184  - 1439
 Night 0 - 351
 Dawn  352 - 383
 Day   384 - 1151
 Dusk  1152 - 1183
 */

typedef struct
{
    n_byte4     date;                                  /* save-able */
    n_byte2     genetics[2];                           /* save-able */
    n_byte2     time;                                  /* save-able */

    n_byte      topology[MAP_AREA];                    /* generated */
    n_byte      topology_highdef[HI_RES_MAP_AREA * 2]; /* generated */
    n_byte4     highres_tide[HI_RES_MAP_AREA/32];      /* generated */
    n_byte2     delta_pressure[ MAP_AREA / 4];         /* generated */
    n_c_int             atmosphere[ MAP_AREA / 4];             /* save-able and generate-able */
    n_byte      tide_level;                            /* generated */
}
n_land;

void  weather_init(n_land * local_land);
void  weather_wind_vector(n_land * local_land, n_vect2 * pos, n_vect2 * wind);
n_int weather_pressure(n_land * local_land, n_int px, n_int py);
void  weather_cycle(n_land * local_land);
weather_values weather_seven_values(n_land * local_land, n_int px, n_int py);

void  land_init(n_land * local_land, n_byte * scratch, n_byte double_spread);
void  land_clear(n_land * local, KIND_OF_USE kind, n_byte4 start);
void  land_cycle(n_land * local_land);
void  land_vect2(n_vect2 * output, n_int * actual_z, n_land * local, n_vect2 * location);
n_int land_operator_interpolated(n_land * local_land, n_int locx, n_int locy, n_byte * kind);

n_int land_map_dimension(n_land * land);
n_int land_map_bits(n_land * land);

void land_tide(n_land * local_land);
n_int land_location(n_land * land, n_int px, n_int py);


/*0*/

enum PRIMARY_APESCRIPT
{
    VARIABLE_FUNCTION = 0,
    VARIABLE_RUN,
    VARIABLE_WHILE,
    VARIABLE_IF
};

enum SYNTAX_APESCRIPT
{
    SYNTAX_MINUS = 0,
    SYNTAX_ADDITION,
    SYNTAX_MULTIPLY,
    SYNTAX_AND,
    SYNTAX_XOR,
    SYNTAX_OR,

    SYNTAX_GREATER_THAN,
    SYNTAX_LESS_THAN,
    SYNTAX_EQUAL_TO,
    SYNTAX_NOT_EQUAL_TO,
    SYNTAX_CONDITIONAL_AND,
    SYNTAX_CONDITIONAL_OR,
    SYNTAX_DIVISION,

    SYNTAX_MODULUS,

    SYNTAX_BITSHIFT_RIGHT,
    SYNTAX_BITSHIFT_LEFT,

    SYNTAX_LESS_EQUAL,
    SYNTAX_GREATER_EQUAL,

    SYNTAX_EQUALS
};

enum SYNTAX_ADDITIONAL_BRAINCODE
{
    SYNTAX_MOVE = SYNTAX_EQUALS + 1,
    SYNTAX_JUMP_TO,
    SYNTAX_JUMP_EQUAL_ZERO,
    SYNTAX_DATA
};

enum APESCRIPT_INTERPRET_TYPES
{
    APESCRIPT_OPEN_BRACKET =  ('('),
    APESCRIPT_CLOSE_BRACKET = (')'),
    APESCRIPT_OPEN_BRACE =    ('{'),
    APESCRIPT_CLOSE_BRACE =   ('}'),
    APESCRIPT_OPERATOR =      ('='),
    APESCRIPT_NUMBER =        ('n'),
    APESCRIPT_TEXT =          ('t'),
    APESCRIPT_SEMICOLON =     (';'),
    APESCRIPT_FAILURE =       ('F'),
    APESCRIPT_FUNCTION =      ('f'),
    APESCRIPT_RUN =           ('r'),
    APESCRIPT_STRING =        ('"')
};

#define ASCII_QUOTE(num)      ((num) == '"')

#define ASCII_TEXT(num)           ((ASCII_UPPERCASE(num) || ASCII_LOWERCASE(num)) || ((num) == '_'))

#define ASCII_SEMICOLON(num)  ((num) == ';')

#define ASCII_EQUAL(num)          ((num) == '=')

#define ASCII_BRACKET(num)    (((num) == '(')||((num) == ')'))
#define ASCII_BRACES(num)     (((num) == '{')||((num) == '}'))

#define ASCII_LOGICAL(num)        ((((num) == '&')||((num) == '|'))||(((num) == '^')||((num) == '!')))
#define ASCII_ARITHMETIC(num) ((((num) == '+')||((num) == '-'))||(((num) == '*')||((num) == '/')))

#define ASCII_DIRECTIONAL(num) (((num)=='<')||((num)=='>'))

#define CODE_VALUE_REQUIRED(num) (((num) == APESCRIPT_OPERATOR || (num) == APESCRIPT_NUMBER) || ((num) == APESCRIPT_TEXT))

#define SIZEOF_NUMBER_WRITE      (sizeof(n_int))

void io_int_to_bytes(n_int value, n_byte * bytes);
n_int io_bytes_to_int(n_byte * bytes);

#define VARIABLE_INPUT(num,code)                ((num)>((code)->input_greater))
#define VARIABLE_SPECIAL(num,code)          ((num)<((code)->special_less))

#ifndef ABS
#define ABS(a)                          (((a) < 0) ? -(a) : (a))
#endif

#define NUMBER_MAX                              256
#define VARIABLE_MAX                    256

#define BRACES_MAX                          16
#define SIZE_OF_EVALUATE            (SIZEOF_NUMBER_WRITE+SIZEOF_NUMBER_WRITE+1)  /* (tA=XtB) */

#define CYCLE_COUNT_RESET           4096

#define MAIN_NOT_RUN                0
#define MAIN_RUN                            1

typedef n_int (script_input )(void * individual, n_byte kind, n_int value);

typedef n_int (script_output)(void * code, void * individual, n_byte * kind, n_int * number);

typedef void (script_external)(void * individual, void * structure, void * data);

#define VARIABLE_WIDTH              32

typedef n_byte                              variable_string[VARIABLE_WIDTH];

typedef struct
{
    n_byte                       evaluate[SIZE_OF_EVALUATE];
    n_int                        braces_start;
} n_brace;


typedef struct
{
    n_file                      *binary_code;
    n_int                        number_buffer[NUMBER_MAX]; /* per entry */
    variable_string *variable_strings;
    n_int                    main_entry;
    n_int                    input_greater;
    n_int                    special_less;
    script_input    *sc_input;
    script_output   *sc_output;
} n_interpret;

typedef struct
{
    n_int           interpret_location; /* per entry */
    n_int           leave;              /* per entry */
    n_int           localized_leave;    /* per entry */
    void *          interpret_data;     /* per entry */
    n_int                   variable_references[VARIABLE_MAX]; /* per entry */
    n_int                   braces_count;        /* per entry */
    n_brace                 braces[BRACES_MAX];  /* per entry */
    n_byte                  main_status;         /* per entry */
} n_individual_interpret;


/* used for stripping ApeScript errors for documentation */

n_int io_apescript_error(void * ptr, AE_ENUM value);

n_interpret *   parse_convert(n_file * input, n_int main_entry, variable_string * variables);

void interpret_individual(n_individual_interpret * individual);

void  interpret_cleanup(n_interpret ** to_clean);
n_int interpret_cycle(n_interpret * code, n_individual_interpret * individual, n_int exit_offset,
                      void * structure, void * data,
                      script_external * start, script_external * end);

#ifdef  SCRIPT_DEBUG

n_file * scdebug_file_ready(void);
void     scdebug_file_cleanup(void);

void     scdebug_string(void * ptr, n_constant_string string);
void     scdebug_int(void * ptr, n_int number);
void     scdebug_newline(void * ptr);
void     scdebug_tabstep(void * ptr, n_int steps);
n_string scdebug_variable(n_int variable);

void     scdebug_writeon(void * ptr);
void     scdebug_writeoff(void * ptr);

n_int spacetime_after(n_spacetime * initial, n_spacetime * second);
void  spacetime_copy(n_spacetime * to, n_spacetime * from);
n_int spacetime_before_now(n_spacetime * initial, n_land * now);
void  spacetime_set(n_spacetime * set, n_land * local, n_byte2 * location);


#define SC_DEBUG_STRING(ptr, string)    scdebug_string(ptr, string)
#define SC_DEBUG_NUMBER(ptr, number) scdebug_int(ptr, number)
#define SC_DEBUG_NEWLINE(ptr)           scdebug_newline(ptr)
#define SC_DEBUG_UP(ptr)                        scdebug_tabstep(ptr,1)
#define SC_DEBUG_DOWN(ptr)                      scdebug_tabstep(ptr,-1)
#define SC_DEBUG_ON(ptr)            scdebug_writeon(ptr)
#define SC_DEBUG_OFF(ptr)                       scdebug_writeoff(ptr)

#else

#define SC_DEBUG_STRING(string) /* string */
#define SC_DEBUG_NUMBER(number) /* number */
#define SC_DEBUG_NEWLINE                /* */
#define SC_DEBUG_UP                             /* */
#define SC_DEBUG_DOWN                   /* */
#define SC_DEBUG_ON(ptr)                /* ptr */
#define SC_DEBUG_OFF                    /* */

#endif

#endif /* _NOBLEAPE_NOBLE_H_ */