int main(int argc, char *argv[])
{
player_maze maze;
SDL_on_off SDL_indicator = SDL_off;
possible_impossible solveable_indicator;
int maze_dims[NUM_DIMENSIONS];
int entrance_coords[NUM_DIMENSIONS];
SDL_Simplewin sw;
clear_screen();
check_command_line_args(argc, argv, &SDL_indicator, maze, maze_dims, &sw);
find_entrance(maze, maze_dims, entrance_coords, &sw, SDL_indicator);
solveable_indicator = solve_maze(maze, maze_dims, entrance_coords[row], entrance_coords[col], &sw, entrance_coords);
end_action(maze, maze_dims, solveable_indicator, &sw, SDL_indicator);
if(SDL_indicator == SDL_on){
// Clear up graphics subsystems
atexit(SDL_Quit);
}
return(solveable_indicator);
}
int BEE::Timeline::end() {
pause_offset = 0;
is_paused = false;
if (end_action == nullptr) {
return 1;
}
end_action();
return 0;
}
/**
* Execute a BPF program
* @param prg the loaded BPF program
* @param sys_data the syscall record being tested
*
* Simulate the BPF program with the given syscall record.
*
*/
static void bpf_execute(const struct bpf_program *prg,
const struct seccomp_data *sys_data)
{
unsigned int ip, ip_c;
struct sim_state state;
bpf_instr_raw *bpf;
unsigned char *sys_data_b = (unsigned char *)sys_data;
uint16_t code;
uint8_t jt;
uint8_t jf;
uint32_t k;
/* initialize the machine state */
ip_c = 0;
ip = 0;
memset(&state, 0, sizeof(state));
while (ip < prg->i_cnt) {
/* get the instruction and bump the ip */
ip_c = ip;
bpf = &prg->i[ip++];
code = ttoh16(arch, bpf->code);
jt = bpf->jt;
jf = bpf->jf;
k = ttoh32(arch, bpf->k);
switch (code) {
case BPF_LD+BPF_W+BPF_ABS:
if (k < BPF_SYSCALL_MAX) {
uint32_t val = *((uint32_t *)&sys_data_b[k]);
state.acc = ttoh32(arch, val);
} else
exit_error(ERANGE, ip_c);
break;
case BPF_ALU+BPF_OR+BPF_K:
state.acc |= k;
break;
case BPF_ALU+BPF_AND+BPF_K:
state.acc &= k;
break;
case BPF_JMP+BPF_JA:
ip += k;
break;
case BPF_JMP+BPF_JEQ+BPF_K:
if (state.acc == k)
ip += jt;
else
ip += jf;
break;
case BPF_JMP+BPF_JGT+BPF_K:
if (state.acc > k)
ip += jt;
else
ip += jf;
break;
case BPF_JMP+BPF_JGE+BPF_K:
if (state.acc >= k)
ip += jt;
else
ip += jf;
break;
case BPF_RET+BPF_K:
end_action(k, ip_c);
break;
default:
/* since we don't support the full bpf language just
* yet, this could be either a fault or an error, we'll
* treat it as a fault until we provide full support */
exit_fault(EOPNOTSUPP);
}
}
/* if we've reached here there is a problem with the program */
exit_error(ERANGE, ip_c);
}
Generator::Generator(Engine *engine)
:
OptionNode{"Generator"},
assetmanager{engine->get_data_dir()},
spec{std::make_shared<GameSpec>(this->assetmanager)} {
// node settings
this->set_parent(engine);
this->add("generation_seed", 4321);
this->add("terrain_size", 2);
this->add("terrain_base_id", 0);
this->add("player_area", 850);
this->add("player_radius", 10);
this->add("load_filename", "/tmp/default_save.oas");
this->add("player_names", options::option_list{"name1", "name2"});
// Save game functions
options::OptionAction save_action("save_game", [this]() {
Engine &engine = Engine::get();
if (!engine.get_game()) {
return options::OptionValue("Error: no open game to save");
}
auto filename = this->get_variable("load_filename").value<std::string>();
gameio::save(engine.get_game(), filename);
return options::OptionValue("Game saved");
});
this->add_action(save_action);
// Load game function
options::OptionAction load_action("load_game", [this]() {
Engine &engine = Engine::get();
if (engine.get_game()) {
return options::OptionValue("Error: close existing game before loading");
}
else if (!this->spec->load_complete()) {
return options::OptionValue("Error: game data has not finished loading");
}
auto filename = this->get_variable("load_filename").value<std::string>();
// create an empty game
this->regions.clear();
engine.start_game(*this);
gameio::load(engine.get_game(), filename);
return options::OptionValue("Game loaded");
});
this->add_action(load_action);
// create a game using this generator
options::OptionAction start_action("generate_game", [this]() {
if (this->create()) {
return options::OptionValue("Game generated");
}
return options::OptionValue("Error: game data has not finished loading");
});
this->add_action(start_action);
// stop game
options::OptionAction end_action("end_game", [this]() {
Engine &engine = Engine::get();
engine.end_game();
return options::OptionValue("Game ended");
});
this->add_action(end_action);
// reload all assets
options::OptionAction reload_action("reload_assets", [this]() {
if (!this->spec->load_complete()) {
return options::OptionValue("Error: game data has not finished loading");
}
this->assetmanager.check_updates();
this->spec = std::make_shared<GameSpec>(this->assetmanager);
return options::OptionValue("Starting asset reload");
});
this->add_action(reload_action);
}
