int generate_fold(int x, int y, int stack_size) {
// if the point met the requirements, place it in stack
if (check_point(x, y, stack_size)){
stack[stack_size].x = x;
stack[stack_size].y = y;
stack_size++;
}else{
return -1;
}
// we found a shape, compute optima H-H points for each protein
if (stack_size == LENGTH){
stack_size--;
init_fill();
stack[LENGTH].x = 0;
stack[LENGTH].y = 0;
}
else {
// keep looking in each 4 directions
generate_fold(x+1, y, stack_size);
generate_fold(x, y+1, stack_size);
generate_fold(x-1, y, stack_size);
generate_fold(x, y-1, stack_size);
}
}
void
mkmap(lev_init *init_lev)
{
schar bg_typ = init_lev->bg,
fg_typ = init_lev->fg;
boolean smooth = init_lev->smoothed,
join = init_lev->joined;
xchar lit = init_lev->lit,
walled = init_lev->walled;
int i;
if(lit < 0)
lit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77)) ? 1 : 0;
new_locations = (char *)alloc((WIDTH+1) * HEIGHT);
if (bg_typ < MAX_TYPE)
init_map(bg_typ);
init_fill(bg_typ, fg_typ);
for(i = 0; i < N_P1_ITER; i++)
pass_one(bg_typ, fg_typ);
for(i = 0; i < N_P2_ITER; i++)
pass_two(bg_typ, fg_typ);
if(smooth)
for(i = 0; i < N_P3_ITER; i++)
pass_three(bg_typ, fg_typ);
if(join)
join_map(bg_typ, fg_typ);
finish_map(fg_typ, bg_typ, (boolean)lit, (boolean)walled);
/* a walled, joined level is cavernous, not mazelike -dlc
*
* also, caverns have a defined "inside" and "outside"; the outside
* doesn't _have_ to be stone, say, for hell. so if the player
* defined a maze filler originally, go ahead and backfill the
* background in with that filler - DSR */
if (walled && join && (init_lev->filling > -1)) {
level.flags.is_maze_lev = FALSE;
level.flags.is_cavernous_lev = TRUE;
backfill(bg_typ,init_lev->filling);
}
free(new_locations);
}
void
mkmap(struct level *lev, lev_init *init_lev)
{
schar bg_typ = init_lev->bg, fg_typ = init_lev->fg;
boolean smooth = init_lev->smoothed, join = init_lev->joined;
xchar lit = init_lev->lit, walled = init_lev->walled;
int i;
if (lit < 0)
lit = (mklev_rn2(1 + abs(depth(&u.uz)), lev) < 10 &&
mklev_rn2(77, lev)) ? 1 : 0;
new_locations = malloc((WIDTH + 1) * HEIGHT);
init_map(lev, bg_typ);
init_fill(lev, bg_typ, fg_typ);
for (i = 0; i < N_P1_ITER; i++)
pass_one(lev, bg_typ, fg_typ);
for (i = 0; i < N_P2_ITER; i++)
pass_two(lev, bg_typ, fg_typ);
if (smooth)
for (i = 0; i < N_P3_ITER; i++)
pass_three(lev, bg_typ, fg_typ);
if (join)
join_map(lev, bg_typ, fg_typ);
finish_map(lev, fg_typ, bg_typ, (boolean) lit, (boolean) walled);
/* a walled, joined level is cavernous, not mazelike -dlc */
if (walled && join) {
lev->flags.is_maze_lev = FALSE;
lev->flags.is_cavernous_lev = TRUE;
}
free(new_locations);
}
static int write_file(const char *filename, char *zero_buf, char *nonzero_buf)
{
int i, fd, count, ret = 0;
char *buf;
init_fill();
qprintf("Write file \"%s\"\n", filename);
fd = open(filename, O_WRONLY|O_CREAT, 0644);
if (fd < 0) {
ret = errno;
warn("Error while opening %s", filename);
return ret;
}
for (i = 0; i < size_blocks; i++) {
buf = select_buf(zero_buf, nonzero_buf);
count = write(fd, buf, blocksize);
if (count < blocksize) {
if (count >= 0) {
ret = EIO;
fprintf(stderr, "Short write from file %s\n",
filename);
} else {
ret = errno;
warn("While writing %s", filename);
}
goto out_close;
}
}
out_close:
close(fd);
return ret;
}
