void apply_create_sigarray(struct apply_handle *h, struct fsm *net) {
struct sigma *sig;
struct fsm_state *fsm;
int i, maxsigma;
fsm = net->states;
maxsigma = sigma_max(net->sigma);
// Default size created at init, resized later if necessary
h->sigmatch_array = xxcalloc(1024,sizeof(struct sigmatch_array));
h->sigmatch_array_size = 1024;
h->sigs = xxmalloc(sizeof(char **)*(maxsigma+1));
h->has_flags = 0;
h->flag_list = NULL;
/* Malloc first array of trie and store trie ptrs to free later */
h->sigma_trie = xxcalloc(256,sizeof(struct sigma_trie));
h->sigma_trie_arrays = xxmalloc(sizeof(struct sigma_trie_arrays));
h->sigma_trie_arrays->arr = h->sigma_trie;
h->sigma_trie_arrays->next = NULL;
for (i=0;i<256;i++)
(h->sigma_trie+i)->next = NULL;
for (sig = h->gsigma; sig != NULL && sig->number != -1; sig = sig->next) {
if (flag_check(sig->symbol)) {
h->has_flags = 1;
apply_add_flag(h, flag_get_name(sig->symbol));
}
*(h->sigs+(sig->number)) = sig->symbol;
/* Add sigma entry to trie */
if (sig->number > IDENTITY) {
apply_add_sigma_trie(h, sig->number, sig->symbol);
}
}
if (h->has_flags) {
h->flag_lookup = xxmalloc(sizeof(struct flag_lookup)*(maxsigma+1));
for (i=0; i <= maxsigma; i++) {
(h->flag_lookup+i)->type = 0;
(h->flag_lookup+i)->name = NULL;
(h->flag_lookup+i)->value = NULL;
}
for (sig = h->gsigma; sig != NULL ; sig = sig->next) {
if (flag_check(sig->symbol)) {
(h->flag_lookup+sig->number)->type = flag_get_type(sig->symbol);
(h->flag_lookup+sig->number)->name = flag_get_name(sig->symbol);
(h->flag_lookup+sig->number)->value = flag_get_value(sig->symbol);
}
}
}
}
u8 trainerflag_read_fix(void *script_location) {
script_location += 2;
u16 flag = load_hword(script_location);
// dprintf("trainerflag_read_fix: 0x%x", flag);
flag = trainerflag_fix_difficulty(flag + TRAINER_FLAG_SPACE_START);
return flag_check(flag);
}
void sp135(void)
{
for (u8 i = 0; i < (sizeof(coord_array)/2); i++)
{
if (flag_check(flag_start+i) == 1)
setmaptile_three_nibbles((u16)coord_array[i][0]+7, (u16)coord_array[i][1]+7, tblock_2);
}
return;
}
struct flags *flag_extract (struct fsm *net) {
struct sigma *sigma;
struct flags *flags, *flagst;
flags = NULL;
for (sigma = net->sigma ; sigma != NULL; sigma = sigma->next) {
if (flag_check(sigma->symbol)) {
flagst = xxmalloc(sizeof(struct flags));
flagst->next = flags;
flags = flagst;
flags->type = flag_get_type(sigma->symbol);
flags->name = flag_get_name(sigma->symbol);
flags->value = flag_get_value(sigma->symbol);
}
}
return(flags);
}
void flag_purge (struct fsm *net, char *name) {
struct fsm_state *fsm;
struct sigma *sigma;
int i, *ftable, sigmasize;
char *csym;
sigmasize = sigma_max(net->sigma)+1;
ftable = xxmalloc(sizeof(int) * sigmasize);
fsm = net->states;
for (i=0; i<sigmasize; i++)
*(ftable+i)=0;
for (sigma = net->sigma; sigma != NULL && sigma->number != -1; sigma = sigma->next) {
if (flag_check(sigma->symbol)) {
if (name == NULL) {
*(ftable+(sigma->number)) = 1;
} else {
csym = (sigma->symbol) + 3;
if (strncmp(csym,name,strlen(name)) == 0 && (strlen(csym)>strlen(name)) && (strncmp(csym+strlen(name),".",1) == 0 || strncmp(csym+strlen(name),"@",1) == 0)) {
*(ftable+(sigma->number)) = 1;
}
}
}
}
for (i = 0; i < sigmasize; i++) {
if (*(ftable+i)) {
net->sigma = sigma_remove_num(i, net->sigma);
}
}
for (i=0; (fsm+i)->state_no != -1; i++) {
if ((fsm+i)->in >= 0 && (fsm+i)->out >= 0) {
if (*(ftable+(fsm+i)->in))
(fsm+i)->in = EPSILON;
if (*(ftable+(fsm+i)->out))
(fsm+i)->out = EPSILON;
}
}
xxfree(ftable);
net->is_deterministic = net->is_minimized = net->is_epsilon_free = NO;
return;
}
bool trainer_check_flag_on_spot(u8 npc_id) {
void *script = npc_get_script_by_npc_id(npc_id);
/* probably inject some script execution here */
u16 flag = tb_modify_flag_id(load_hword(script + 2));
/* check for line of sight */
u8 hit_result = npc_trainer_and_raycast_hit(&npc_states[npc_id]);
if (hit_result == 0)
return false;
if (flag_check(trainerflag_fix_difficulty(flag + TRAINER_FLAG_SPACE_START)))
return false;
if ((load_byte(script + 1) == 4) && (player_cant_double_battle() > 0))
return false;
spot_trainer_8080334(npc_id, script);
spot_trainer_8081E68(&npc_states[npc_id], hit_result - 1);
return true;
}
void apply_create_sigarray(struct apply_handle *h, struct fsm *net) {
struct sigma *sig;
int i, maxsigma;
maxsigma = sigma_max(net->sigma);
h->sigma_size = maxsigma+1;
// Default size created at init, resized later if necessary
h->sigmatch_array = xxcalloc(1024,sizeof(struct sigmatch_array));
h->sigmatch_array_size = 1024;
h->sigs = xxmalloc(sizeof(struct sigs)*(maxsigma+1));
h->has_flags = 0;
h->flag_list = NULL;
/* Malloc first array of trie and store trie ptrs to be able to free later */
/* when apply_clear() is called. */
h->sigma_trie = xxcalloc(256,sizeof(struct sigma_trie));
h->sigma_trie_arrays = xxmalloc(sizeof(struct sigma_trie_arrays));
h->sigma_trie_arrays->arr = h->sigma_trie;
h->sigma_trie_arrays->next = NULL;
for (i=0;i<256;i++)
(h->sigma_trie+i)->next = NULL;
for (sig = h->gsigma; sig != NULL && sig->number != -1; sig = sig->next) {
if (flag_check(sig->symbol)) {
h->has_flags = 1;
apply_add_flag(h, flag_get_name(sig->symbol));
}
(h->sigs+(sig->number))->symbol = sig->symbol;
(h->sigs+(sig->number))->length = strlen(sig->symbol);
/* Add sigma entry to trie */
if (sig->number > IDENTITY) {
apply_add_sigma_trie(h, sig->number, sig->symbol, (h->sigs+(sig->number))->length);
}
}
if (maxsigma >= IDENTITY) {
(h->sigs+EPSILON)->symbol = "0";
(h->sigs+EPSILON)->length = 1;
(h->sigs+UNKNOWN)->symbol = "?";
(h->sigs+UNKNOWN)->length = 1;
(h->sigs+IDENTITY)->symbol = "@";
(h->sigs+IDENTITY)->length = 1;
}
if (h->has_flags) {
h->flag_lookup = xxmalloc(sizeof(struct flag_lookup)*(maxsigma+1));
for (i=0; i <= maxsigma; i++) {
(h->flag_lookup+i)->type = 0;
(h->flag_lookup+i)->name = NULL;
(h->flag_lookup+i)->value = NULL;
}
for (sig = h->gsigma; sig != NULL ; sig = sig->next) {
if (flag_check(sig->symbol)) {
(h->flag_lookup+sig->number)->type = flag_get_type(sig->symbol);
(h->flag_lookup+sig->number)->name = flag_get_name(sig->symbol);
(h->flag_lookup+sig->number)->value = flag_get_value(sig->symbol);
}
}
apply_mark_flagstates(h);
}
}
struct fsm *flag_twosided(struct fsm *net) {
struct fsm_state *fsm;
struct sigma *sigma;
int i, j, tail, *isflag, maxsigma, maxstate, newarcs, change;
/* Enforces twosided flag diacritics */
/* Mark flag symbols */
maxsigma = sigma_max(net->sigma);
isflag = xxcalloc(maxsigma+1, sizeof(int));
fsm = net->states;
for (sigma = net->sigma ; sigma != NULL; sigma = sigma->next) {
if (flag_check(sigma->symbol)) {
*(isflag+sigma->number) = 1;
} else {
*(isflag+sigma->number) = 0;
}
}
maxstate = 0;
change = 0;
for (i = 0, newarcs = 0; (fsm+i)->state_no != -1 ; i++) {
maxstate = (fsm+i)->state_no > maxstate ? (fsm+i)->state_no : maxstate;
if ((fsm+i)->target == -1)
continue;
if (*(isflag+(fsm+i)->in) && (fsm+i)->out == EPSILON) {
change = 1;
(fsm+i)->out = (fsm+i)->in;
}
else if (*(isflag+(fsm+i)->out) && (fsm+i)->in == EPSILON) {
change = 1;
(fsm+i)->in = (fsm+i)->out;
}
if ((*(isflag+(fsm+i)->in) || *(isflag+(fsm+i)->out)) && (fsm+i)->in != (fsm+i)->out) {
newarcs++;
}
}
if (newarcs == 0) {
if (change == 1) {
net->is_deterministic = UNK;
net->is_minimized = UNK;
net->is_pruned = UNK;
return fsm_topsort(fsm_minimize(net));
}
return net;
}
net->states = xxrealloc(net->states, sizeof(struct fsm)*(i+newarcs));
fsm = net->states;
tail = j = i;
maxstate++;
for (i = 0; i < tail; i++) {
if ((fsm+i)->target == -1)
continue;
if ((*(isflag+(fsm+i)->in) || *(isflag+(fsm+i)->out)) && (fsm+i)->in != (fsm+i)->out) {
if (*(isflag+(fsm+i)->in) && !*(isflag+(fsm+i)->out)) {
j = add_fsm_arc(fsm, j, maxstate, EPSILON, (fsm+i)->out, (fsm+i)->target, 0, 0);
(fsm+i)->out = (fsm+i)->in;
(fsm+i)->target = maxstate;
maxstate++;
}
else if (*(isflag+(fsm+i)->out) && !*(isflag+(fsm+i)->in)) {
j = add_fsm_arc(fsm, j, maxstate, (fsm+i)->out, (fsm+i)->out, (fsm+i)->target, 0, 0);
(fsm+i)->out = EPSILON;
(fsm+i)->target = maxstate;
maxstate++;
}
else if (*(isflag+(fsm+i)->in) && *(isflag+(fsm+i)->out)) {
j = add_fsm_arc(fsm, j, maxstate, (fsm+i)->out, (fsm+i)->out, (fsm+i)->target, 0, 0);
(fsm+i)->out = (fsm+i)->in;
(fsm+i)->target = maxstate;
maxstate++;
}
}
}
/* Add sentinel */
add_fsm_arc(fsm, j, -1, -1, -1, -1, -1, -1);
net->is_deterministic = UNK;
net->is_minimized = UNK;
return fsm_topsort(fsm_minimize(net));
}
// 08080424
bool trainer_flag_check(u16 trainer_id) {
return flag_check(trainer_id+0x500);
}
bool trainerflag_check_fix(u16 flag) { return flag_check(trainerflag_fix_difficulty(flag + TRAINER_FLAG_SPACE_START)); }
u16 trainerflag_fix_difficulty(u16 flag_id) {
u16 new_flag = ((flag_id - TRAINER_FLAG_SPACE_START + 1) / 3) + TRAINER_FLAG_SPACE_START;
dprintf("trainerflag_fix_difficulty;; flag_id: 0x%x, reduced: 0x%x, status: %s\n", flag_id, new_flag,
flag_check(new_flag) ? "true" : "false");
return new_flag;
}
