inkcpp.h

#ifndef _INKCPP_H
#define _INKCPP_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#else
typedef struct HInkSnapshot HInkSnapshot;
typedef struct HInkChoice   HInkChoice;
typedef struct HInkList     HInkList;
typedef struct InkListIter  InkListIter;
typedef struct InkFlag      InkFlag;
typedef struct InkValue     InkValue;
typedef struct HInkRunner   HInkRunner;
typedef struct HInkGlobals  HInkGlobals;
typedef struct HInkSTory    HInkStory;
#endif
    typedef uint32_t ink_hash_t;
 
    struct HInkSnapshot;
    HInkSnapshot* ink_snapshot_from_file(const char* filename);
    HInkSnapshot*
         ink_snapshot_from_binary(const unsigned char* data, size_t length, bool freeOnDestroy);
    int  ink_snapshot_num_runners(const HInkSnapshot* self);
    void ink_snapshot_write_to_file(const HInkSnapshot* self, const char* filename);
    void ink_snapshot_get_binary(
        const HInkSnapshot* self, const unsigned char** data, size_t* data_length
    );
    bool ink_snapshot_can_be_migrated(const HInkSnapshot* self);
 
    struct HInkChoice;
    const char* ink_choice_text(const HInkChoice* self);
    int         ink_choice_num_tags(const HInkChoice* self);
    const char* ink_choice_get_tag(const HInkChoice* self, int index);
 
    struct HInkList;
 
    struct InkListIter {
        const void* _data;        
        int         _i;           
        int         _single_list; 
        const char* flag_name;    
        const char* list_name;    
    };
 
    void ink_list_add(HInkList* self, const char* flag_name);
    void ink_list_remove(HInkList* self, const char* flag_name);
    int  ink_list_contains(const HInkList* self, const char* flag_name);
    int  ink_list_flags(const HInkList* self, InkListIter* iter);
    int  ink_list_flags_from(const HInkList* self, const char* list_name, InkListIter* iter);
    int  ink_list_iter_next(InkListIter* self);
 
    struct InkValue {
        union {
            int bool_v; 
            uint32_t    uint32_v; 
            int32_t     int32_v;  
            const char* string_v; 
            float       float_v;  
            HInkList*
                list_v; 
        };
 
        enum Type {
            ValueTypeNone,   
            ValueTypeBool,   
            ValueTypeUint32, 
            ValueTypeInt32,  
            ValueTypeString, 
            ValueTypeFloat,  
            ValueTypeList    
        } type;            
    };
 
    // const char* ink_value_to_string(const InkValue* self);
 
    typedef InkValue (*InkExternalFunction)(int argc, const InkValue argv[]);
    typedef void (*InkExternalFunctionVoid)(int argc, const InkValue argv[]);
 
    struct HInkRunner;
    void              ink_runner_delete(HInkRunner* self);
    HInkSnapshot*     ink_runner_create_snapshot(const HInkRunner* self);
    int               ink_runner_can_continue(const HInkRunner* self);
    const char*       ink_runner_get_line(HInkRunner* self);
    int               ink_runner_num_tags(const HInkRunner* self);
    const char*       ink_runner_tag(const HInkRunner* self, int index);
    int               ink_runner_num_knot_tags(const HInkRunner* self);
    ink_hash_t        ink_runner_current_knot(const HInkRunner* self);
    bool              ink_runner_move_to(HInkRunner* self, ink_hash_t path);
    ink_hash_t        ink_hash_string(const char* str);
    const char*       ink_runner_knot_tag(const HInkRunner* self, int index);
    int               ink_runner_num_global_tags(const HInkRunner* self);
    const char*       ink_runner_global_tag(const HInkRunner* self, int index);
    int               ink_runner_num_choices(const HInkRunner* self);
    const HInkChoice* ink_runner_get_choice(const HInkRunner* self, int index);
    void              ink_runner_choose(HInkRunner* self, int index);
 
    void ink_runner_bind_void(
        HInkRunner* self, const char* function_name, InkExternalFunctionVoid callback,
        int lookaheadSafe
    );
    void ink_runner_bind(
        HInkRunner* self, const char* function_name, InkExternalFunction callback, int lookaheadSafe
    );
 
 
    struct HInkGlobals;
    typedef void (*InkObserver)(InkValue new_value, InkValue old_value);
    void          ink_globals_delete(HInkGlobals* self);
    HInkSnapshot* ink_globals_create_snapshot(const HInkGlobals* self);
    void     ink_globals_observe(HInkGlobals* self, const char* variable_name, InkObserver observer);
    InkValue ink_globals_get(const HInkGlobals* self, const char* variable_name);
    int      ink_globals_set(HInkGlobals* self, const char* variable_name, InkValue value);
 
    struct HInkStory;
    HInkStory*   ink_story_from_file(const char* filename);
    HInkStory*   ink_story_from_binary(const unsigned char* data, size_t length, bool freeOnDestroy);
    void         ink_story_delete(HInkStory* self);
    HInkGlobals* ink_story_new_globals(HInkStory* self);
    HInkRunner*  ink_story_new_runner(HInkStory* self, HInkGlobals* store);
    HInkGlobals* ink_story_new_globals_from_snapshot(HInkStory* self, const HInkSnapshot* obj);
    HInkRunner*  ink_story_new_runner_from_snapshot(
         HInkStory* self, const HInkSnapshot* obj, HInkGlobals* store, int runner_id
     );
 
    void
        ink_compile_json(const char* input_filename, const char* output_filename, const char** error);
 
 
#ifdef __cplusplus
}
#endif
 
#endif