kst_plan.h

Go to the documentation of this file.

 
#ifndef KST_PLAN_H
#define KST_PLAN_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "kst_limits.h"
#include "kst_reg.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define KST_PLAN_MAX_STEPS 33u

typedef enum {
    KST_PLAN_EDIT = 0,         
    KST_PLAN_RESTORE,          
    KST_PLAN_RELEASE_PAIRING,  
} kst_plan_kind_t;

typedef enum {
    KST_PLAN_OK = 0,        
    KST_PLAN_ERR_ARG,      
    KST_PLAN_ERR_RULES,    
    KST_PLAN_ERR_R00,      
    KST_PLAN_ERR_PAIRING,  
    KST_PLAN_ERR_NO_PATH,  
    KST_PLAN_BUSY,         
    KST_PLAN_ERR_TOO_COMPLEX,  
} kst_plan_result_t;

#define KST_PLAN_NO_CAP 0xFFFFFFFFu
#define KST_PLAN_PIECE_UNITS 10u
#define KST_PLAN_SLICE_UNITS 100u
#define KST_PLAN_WORK_CAP 216000u

typedef struct {
    uint8_t reg;            
    uint8_t value;          
    uint8_t prev;     
    uint8_t settled;  
} kst_write_t;

typedef struct {
    kst_image_t start;       
    kst_image_t target;      
    kst_field_set_t unlocked;  
    uint8_t kind;            
    uint8_t n;               
    uint8_t unchecked;       
    kst_write_t step[KST_PLAN_MAX_STEPS];  
} kst_plan_t;

typedef struct {
    kst_rules_t allowed;     
    kst_plan_t *plan;        
    uint32_t spent;          
    uint32_t cap;                       
    kst_image_t img;         
    uint8_t open[32];        
    uint8_t dead[16];        
    uint8_t known[16];       
    uint8_t sound[16];       
    uint8_t order[7];        
    uint8_t tried[7];        
    uint8_t held[7];         
    uint8_t phase;                      
    uint8_t result;          
    uint8_t may_be_unchecked;           
    uint8_t group;                      
    uint8_t todo_all;        
    uint8_t todo;            
    uint8_t depth;                      
    uint8_t entered;                    
    uint8_t in_detour;                  
    uint8_t field;           
    uint8_t lo;              
    uint8_t lo_before;                  
    uint8_t extra;           
    uint8_t settle;          
    uint16_t x;              
} kst_plan_job_t;

kst_plan_result_t kst_plan_edit_begin(kst_plan_job_t *job,
                                      const kst_image_t *start,
                                      const kst_image_t *target,
                                      kst_field_set_t unlocked,
                                      kst_plan_t *out,
                                      kst_rules_t *violated,
                                      uint32_t cap);

kst_plan_result_t kst_plan_restore_begin(kst_plan_job_t *job,
                                         const kst_image_t *current,
                                         const kst_image_t *backup,
                                         kst_plan_t *out,
                                         uint32_t cap);

kst_plan_result_t kst_plan_step(kst_plan_job_t *job, uint32_t budget);

uint32_t kst_plan_units(const kst_plan_job_t *job);

kst_plan_result_t kst_plan_edit(const kst_image_t *start,
                                const kst_image_t *target,
                                kst_field_set_t unlocked,
                                kst_plan_t *out,
                                kst_rules_t *violated);

kst_plan_result_t kst_plan_restore(const kst_image_t *current,
                                   const kst_image_t *backup,
                                   kst_plan_t *out);

kst_plan_result_t kst_plan_release_pairing(const kst_image_t *current,
                                           kst_plan_t *out);

bool kst_plan_image_after(const kst_plan_t *plan, unsigned steps,
                          kst_image_t *out);
 
#ifdef __cplusplus
}
#endif
 
#endif /* KST_PLAN_H */