static void
generator_add_digger_test(void)
{
struct dungeon *dungeon = dungeon_alloc();
struct dungeon_options *dungeon_options = dungeon_options_alloc_default();
struct generator *generator = generator_alloc(dungeon, global_rnd, dungeon_options, NULL, NULL);
assert(0 == generator->diggers_count);
struct digger *digger1 = generator_add_digger(generator,
point_make(1, 1, 1),
direction_north);
assert(1 == generator->diggers_count);
generator_delete_digger(generator, digger1);
assert(0 == generator->diggers_count);
digger1 = generator_add_digger(generator,
point_make(1, 1, 1),
direction_north);
assert(1 == generator->diggers_count);
struct digger *digger2 = generator_add_digger(generator,
point_make(2, 2, 2),
direction_north);
assert(2 == generator->diggers_count);
struct digger *digger3 = generator_add_digger(generator,
point_make(3, 3, 3),
direction_north);
assert(3 == generator->diggers_count);
generator_delete_digger(generator, digger2);
assert(2 == generator->diggers_count);
assert(digger1 == generator->diggers[0]);
assert(digger3 == generator->diggers[1]);
generator_delete_digger(generator, digger1);
assert(1 == generator->diggers_count);
assert(digger3 == generator->diggers[0]);
generator_free(generator);
dungeon_options_free(dungeon_options);
dungeon_free(dungeon);
}
static void
check_wall_for_secret_door(struct generator *generator,
struct point point,
enum direction direction)
{
struct tile *inside_tile = generator_tile_at(generator, point);
struct tile *outside_tile = generator_tile_at(generator,
point_move(point, 1, direction));
switch (direction) {
case direction_north:
if (wall_type_solid != outside_tile->walls.south) return;
break;
case direction_south:
if (wall_type_solid != inside_tile->walls.south) return;
break;
case direction_east:
if (wall_type_solid != outside_tile->walls.west) return;
break;
case direction_west:
if (wall_type_solid != inside_tile->walls.west) return;
break;
default:
fail("Unrecognized direction %i", direction);
break;
}
int score = roll("1d4", generator->rnd);
if (score == 1) {
if (tile_type_empty == outside_tile->type) {
generator_set_wall(generator,
inside_tile->point,
direction,
wall_type_secret_door);
} else {
struct digger *door_digger = generator_add_digger(generator,
point_move(point, 1, direction),
direction);
if (!space_beyond_door(door_digger, wall_type_secret_door, false)) {
generator_delete_digger(generator, door_digger);
}
}
}
}
