double Map::cast(Player* player, double angle, double dist) {
double x = player->x;
double y = player->y;
double dx = cos(angle);
double dy = sin(angle);
while (distance(player->x, player->y, x, y) < dist) {
double next_x = round(x, dx);
double next_y = round(y, dy);
if ((next_x - x)/dx > (next_y - y)/dy) {
x += ((next_y - y)/dy) * dx;
y = next_y;
double curr_dist = distance(player->x, player->y, x, y);
if (curr_dist < dist && wallgrid[(int)(floor(x) + size*y)] == 1 &&
wallgrid[(int)(ceil(x) + size*y)] == 1 &&
in_bounds(floor(x), y) && in_bounds(ceil(x), y)) {
return curr_dist;
}
} else {
y += ((next_x - x)/dx) * dy;
x = next_x;
double curr_dist = distance(player->x, player->y, x, y);
if (curr_dist < dist && wallgrid[(int)(x + size*floor(y))] == 1 &&
wallgrid[(int)(x + size*ceil(y))] == 1 &&
in_bounds(floor(x), y) && in_bounds(ceil(x), y)) {
return curr_dist;
}
}
}
return INFINITY;
}
/*
* Count the number of walls adjacent to the given grid.
*
* Note -- Assumes "in_bounds(y, x)"
*
* We count only granite walls and permanent walls.
*/
static int next_to_walls(int y, int x)
{
int k = 0;
if (in_bounds(y + 1, x) && is_extra_bold(y + 1, x)) k++;
if (in_bounds(y - 1, x) && is_extra_bold(y - 1, x)) k++;
if (in_bounds(y, x + 1) && is_extra_bold(y, x + 1)) k++;
if (in_bounds(y, x - 1) && is_extra_bold(y, x - 1)) k++;
return (k);
}
/*!
* @brief モンスターにとって所定の地点が召還に相応しい地点かどうかを返す。 /
* Determine if there is a space near the player in which a summoned creature can appear
* @param y1 判定を行いたいマスのY座標
* @param x1 判定を行いたいマスのX座標
* @return 召還に相応しいならばTRUEを返す
*/
bool summon_possible(int y1, int x1)
{
int y, x;
/* Start at the player's location, and check 2 grids in each dir */
for (y = y1 - 2; y <= y1 + 2; y++)
{
for (x = x1 - 2; x <= x1 + 2; x++)
{
/* Ignore illegal locations */
if (!in_bounds(y, x)) continue;
/* Only check a circular area */
if (distance(y1, x1, y, x)>2) continue;
/* ...nor on the Pattern */
if (pattern_tile(y, x)) continue;
/* Require empty floor grid in line of projection */
if (cave_empty_bold(y, x) && projectable(y1, x1, y, x) && projectable(y, x, y1, x1)) return (TRUE);
}
}
return FALSE;
}
int mobility_list(position_t *p, color_t color, square_t* laser_list, int laser_list_len, full_board_t* board) {
int mobility = 0;
square_t king_sq = board->pieces[color][0];
mobility++;
for (int i = 0; i < laser_list_len-1; i++){
square_t start = laser_list[i];
square_t end = laser_list[i+1];
//check if the square is between laser_list[i] and laser_list[i+1]. if so add to mobility
if(between(rnk_of(king_sq), rnk_of(start), rnk_of(end)) && between(fil_of(king_sq), fil_of(start), fil_of(end))) {
mobility--;
break;
}
}
for (int d = 0; d < 8; ++d) {
square_t sq = king_sq + dir_of(d);
if (in_bounds(sq)) {
mobility++;
//decrement if it is in laser path
for (int i = 0; i < laser_list_len-1; i++){
//check if the square is between laser_list[i] and laser_list[i+1]. if so add to mobility
square_t start = laser_list[i];
square_t end = laser_list[i+1];
if(between(rnk_of(sq), rnk_of(start), rnk_of(end)) && between(fil_of(sq), fil_of(start), fil_of(end))) {
mobility--;
break;
}
}
}
}
return mobility;
}
static void _excavation_spell(int cmd, variant *res)
{
switch (cmd)
{
case SPELL_NAME:
var_set_string(res, "Excavation");
break;
case SPELL_DESC:
var_set_string(res, "You break walls on your quest for treasure! This takes a bit more time, though.");
break;
case SPELL_ENERGY:
{
int n = 200;
if (equip_find_object(TV_DIGGING, SV_ANY))
n -= 120 * p_ptr->lev / 50;
else
n -= 80 * p_ptr->lev / 50;
var_set_int(res, n);
}
break;
case SPELL_CAST:
{
int dir = 5;
bool b = FALSE;
if ( get_rep_dir2(&dir)
&& dir != 5 )
{
int x, y;
y = py + ddy[dir];
x = px + ddx[dir];
if (!in_bounds(y, x))
{
msg_print("You may excavate no further.");
}
else if ( cave_have_flag_bold(y, x, FF_WALL)
|| cave_have_flag_bold(y, x, FF_TREE)
|| cave_have_flag_bold(y, x, FF_CAN_DIG) )
{
msg_print("You dig your way to treasure!");
cave_alter_feat(y, x, FF_TUNNEL);
teleport_player_to(y, x, TELEPORT_NONMAGICAL); /*??*/
b = TRUE;
}
else
{
msg_print("There is nothing to excavate.");
}
}
var_set_bool(res, b);
}
break;
default:
default_spell(cmd, res);
break;
}
}
/*
* Get the indexes of effects at a given effects grid.
*
* Return the number of effect indexes acquired.
*
* Never acquire more than "size" object indexes, and never return a
* number bigger than "size", even if more floor objects exist.
*
*/
int scan_effects_grid(int *effects, int size, int y, int x)
{
int this_x_idx, next_x_idx;
int num = 0;
/* Sanity */
if (!in_bounds(y, x)) return (0);
/* Scan all effects in the grid */
for (this_x_idx = cave_x_idx[y][x]; this_x_idx; this_x_idx = next_x_idx)
{
effect_type *x_ptr;
/* Get the effect */
x_ptr = &x_list[this_x_idx];
/* Get the next effect */
next_x_idx = x_ptr->next_x_idx;
/* Accept this item */
effects[num++] = this_x_idx;
/* Enforce size limit */
if (num >= size) break;
}
/* Result */
return (num);
}
void Map::set_maze_wallgrid(int* mazegrid, int size) {
int WIDTH = 5;
int OFFSET = WIDTH/2 + size*WIDTH*(WIDTH/2);
this->wallgrid = new int[(int) pow(size*WIDTH, 2)];
this->size = size*WIDTH;
//Mark the borders with walls
for (int i = 0; i < size*WIDTH; i++) {
wallgrid[i] = 1;
wallgrid[WIDTH*size*i] = 1;
wallgrid[size*WIDTH*(size*WIDTH - 1) + i] = 1;
wallgrid[WIDTH*size*i + (size*WIDTH - 1)] = 1;
}
//Draw a wall between each 0 and 1 in the grid
for (int i = 0; i < size*size; i++) {
int x = i % size;
int y = i / size;
for (int j = -3; j <= 3; j += 2) {
int x_offset = fmod(j, 3);
int y_offset = j / 3;
int curr_x = x + x_offset;
int curr_y = y + y_offset;
if (in_bounds(curr_x, curr_y) && mazegrid[i] != mazegrid[curr_x + curr_y*size]) {
for (int k = 0; k <= WIDTH/2 + 1; k++) {
wallgrid[OFFSET + (x*WIDTH + x_offset*(WIDTH/2)) + (y*WIDTH + y_offset*(WIDTH/2))*size*WIDTH + k*(x_offset*size*WIDTH + y_offset)] = 1;
wallgrid[OFFSET + (x*WIDTH + x_offset*(WIDTH/2)) + (y*WIDTH + y_offset*(WIDTH/2))*size*WIDTH - k*(x_offset*size*WIDTH + y_offset)] = 1;
}
}
}
}
}
/**
* Hack -- Check for a "known wall" (see below)
*/
static int see_wall(int dir, int y, int x)
{
feature_type *f_ptr;
/* Get the new location */
y += ddy[dir];
x += ddx[dir];
/* Illegal grids are not known walls XXX XXX XXX */
if (!in_bounds(y, x))
return (FALSE);
f_ptr = &f_info[cave_feat[y][x]];
/* Non-wall grids are not known walls */
if (!tf_has(f_ptr->flags, TF_WALL))
return (FALSE);
/* Unknown walls are not known walls */
if (!cave_has(cave_info[y][x], CAVE_MARK))
return (FALSE);
/* Default */
return (TRUE);
}
static void _cavern_creation_spell(int cmd, variant *res)
{
switch (cmd)
{
case SPELL_NAME:
var_set_string(res, "Cavern Creation");
break;
case SPELL_DESC:
var_set_string(res, "Stone to Mud all surrounding walls.");
break;
case SPELL_CAST:
{
int dir, x, y, ct = 0;
for (dir = 0; dir < 8; dir++)
{
y = py + ddy_ddd[dir];
x = px + ddx_ddd[dir];
if (!in_bounds(y, x)) continue;
if (!cave_have_flag_bold(y, x, FF_HURT_ROCK)) continue;
cave_alter_feat(y, x, FF_HURT_ROCK);
ct++;
}
if (ct)
p_ptr->update |= (PU_FLOW | PU_BONUS);
var_set_bool(res, TRUE);
break;
}
default:
default_spell(cmd, res);
break;
}
}
static bool _elemental_healing(int flag)
{
int dir, ct = 0;
if (!cave_have_flag_bold(py, px, flag))
{
msg_print("Failed! You are out of your element!");
return FALSE;
}
for (dir = 0; dir < 8; dir++)
{
int x = px + ddx_ddd[dir];
int y = py + ddy_ddd[dir];
if (!in_bounds(y, x)) continue;
if (cave_have_flag_bold(y, x, flag)) ct++;
}
if (ct < 4)
{
msg_print("Failed! You need to be surrounded by your element!");
return FALSE;
}
msg_print("You bask in your element and slowly feel your life returning ... ");
hp_player(100 + p_ptr->lev * 3);
return TRUE;
}
GArray *
available_squares(Level world, EntitySet * others)
{
unsigned int i;
unsigned int j;
float fi, fj;
GArray * available;
unsigned int * coord;
available = g_array_new(FALSE, FALSE, sizeof(unsigned int *));
for (i = 0; i < level_width; i++)
{
for (j = 0; j < level_height; j++)
{
fi = (float) i;
fj = (float) j;
if (in_bounds(world, fi, fj) && NULL == collision(NULL, fi, fj, others))
{
coord = (unsigned int *) zone(sizeof(int) * 2);
coord[0] = i;
coord[1] = j;
g_array_append_val(available, coord);
}
}
}
return available;
}
/* Always insert into root (first).
If you insert into another node,
you're a dick. */
bool QTnode::insert(Particle p)
{
int i;
bool inserted;
inserted = false;
if (in_bounds(p)) {
if (children.size() == 0) {
/* If we are at a leaf node. Just insert. */
particles.push_back(p);
psize++;
inserted = true;
} else {
/* Otherwise, see if you can store in a child. */
for (i = 0; i < children.size(); i++) {
if (children[i]->in_bounds(p)) {
inserted = children[i]->insert(p);
break;
}
}
}
} else {
/* You are at a singularity. YOLO. */
return false;
}
/* If you inserted a particle into your child,
then re-calculate your number of particles. */
if (inserted) {
recalc_num_particles();
}
return inserted;
}
/**
* Deletes the monster, if any, at the given location.
*/
void delete_monster(int y, int x)
{
assert(in_bounds(y, x));
/* Delete the monster (if any) */
if (cave->m_idx[y][x] > 0)
delete_monster_idx(cave->m_idx[y][x]);
}
/*
* Delete the monster, if any, at a given location
*/
void delete_monster(int y, int x)
{
/* Paranoia */
if (!in_bounds(y, x)) return;
/* Delete the monster (if any) */
if (cave.m_idx[y][x] > 0) delete_monster_idx(cave.m_idx[y][x]);
}
/* returns if samples is in bounds */
int in_bounds( const long D, long *sample, const long *dims ){
if( D == 1 ){
return (sample[0] >= 0 && sample[0] < dims[0]);
}else{
return (sample[0] >= 0 && sample[0] < dims[0])
&& in_bounds(D-1, &sample[1], &dims[1]);
}
}
static bool _place_web(int y, int x)
{
if (!in_bounds(y, x))
return FALSE;
if (!cave_clean_bold(y,x) || cave[y][x].m_idx)
return FALSE;
cave_set_feat(y, x, feat_web);
return TRUE;
}
/*
* Attempt to place an object (normal or good/great) at the given location.
*
* This routine plays nasty games to generate the "special artifacts".
*
* This routine uses "object_level" for the "generation level".
*
* This routine requires a clean floor grid destination.
*/
void place_object(s32b y, s32b x, bool good, bool great, s32b where)
{
object_type *q_ptr;
/* Paranoia -- check bounds */
if (!in_bounds(y, x)) return;
/* Require clean floor space */
if (!cave_clean_bold(y, x)) return;
/* Get local object */
q_ptr = make_object(good, great, NULL);
/* Make an object (if possible) */
if (q_ptr == NULL)
return;
if (where == OBJ_FOUND_VAULT)
{
q_ptr->found = OBJ_FOUND_VAULT;
q_ptr->found_aux1 = dungeon_type;
q_ptr->found_aux2 = level_or_feat(dungeon_type, dun_level);
}
else if (where == OBJ_FOUND_FLOOR)
{
q_ptr->found = OBJ_FOUND_FLOOR;
q_ptr->found_aux1 = dungeon_type;
q_ptr->found_aux2 = level_or_feat(dungeon_type, dun_level);
}
else if (where == OBJ_FOUND_SPECIAL)
{
q_ptr->found = OBJ_FOUND_SPECIAL;
}
else if (where == OBJ_FOUND_RUBBLE)
{
q_ptr->found = OBJ_FOUND_RUBBLE;
}
/* Object array overflow */
if (!floor_carry(y, x, q_ptr))
{
/* Hack -- Preserve artifacts */
if (q_ptr->artifact_id)
{
a_info[q_ptr->artifact_id].cur_num = 0;
}
else if (has_flag(&k_info[q_ptr->k_idx], FLAG_NORM_ART))
{
k_info[q_ptr->k_idx].artifact = 0;
}
delete_object(q_ptr);
}
}
/*
* Create up to "num" objects near the given coordinates
* Only really called by some of the "vault" routines.
*/
void vault_objects(int y, int x, int num)
{
int dummy = 0;
int i = 0, j = y, k = x;
cave_type *c_ptr;
/* Attempt to place 'num' objects */
for (; num > 0; --num)
{
/* Try up to 11 spots looking for empty space */
for (i = 0; i < 11; ++i)
{
/* Pick a random location */
while (dummy < SAFE_MAX_ATTEMPTS)
{
j = rand_spread(y, 2);
k = rand_spread(x, 3);
dummy++;
if (!in_bounds(j, k)) continue;
break;
}
if (dummy >= SAFE_MAX_ATTEMPTS)
{
if (cheat_room)
{
msg_print("Warning! Could not place vault object!");
}
}
/* Require "clean" floor space */
c_ptr = &cave[j][k];
if (!is_floor_grid(c_ptr) || c_ptr->o_idx) continue;
/* Place an item */
if (randint0(100) < 75)
{
place_object(j, k, 0L);
}
/* Place gold */
else
{
place_gold(j, k);
}
/* Placement accomplished */
break;
}
}
}
/*
* Returns random co-ordinates for player/monster/object
*/
bool new_player_spot(void)
{
int y = 0, x = 0;
int max_attempts = 10000;
cave_type *c_ptr;
feature_type *f_ptr;
/* Place the player */
while (max_attempts--)
{
/* Pick a legal spot */
y = rand_range(1, cur_hgt - 2);
x = rand_range(1, cur_wid - 2);
c_ptr = &cave[y][x];
/* Must be a "naked" floor grid */
if (c_ptr->m_idx) continue;
if (dun_level)
{
f_ptr = &f_info[c_ptr->feat];
if (max_attempts > 5000) /* Rule 1 */
{
if (!have_flag(f_ptr->flags, FF_FLOOR)) continue;
}
else /* Rule 2 */
{
if (!have_flag(f_ptr->flags, FF_MOVE)) continue;
if (have_flag(f_ptr->flags, FF_HIT_TRAP)) continue;
}
/* Refuse to start on anti-teleport grids in dungeon */
if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) continue;
}
if (!player_can_enter(c_ptr->feat, 0)) continue;
if (!in_bounds(y, x)) continue;
/* Refuse to start on anti-teleport grids */
if (c_ptr->info & (CAVE_ICKY)) continue;
/* Done */
break;
}
if (max_attempts < 1) /* Should be -1, actually if we failed... */
return FALSE;
/* Save the new player grid */
py = y;
px = x;
return TRUE;
}
//ask the user for a play
void get_play(Board board) {
int enter_row, enter_col;
while(1){ //while still true, keep going through this loop
printf("Enter row a row between 0-%d and a column between 0-%d: ", board.row - 1, board.col - 1);
scanf("%d %d", &enter_row, &enter_col);
enter_row = board.row - enter_row - 1;
if (in_bounds(board, enter_row, enter_col)) {
if (board.tile[enter_row][enter_col].revealed == '!') {
if (option_2(board, enter_row, enter_col)) {
break;
}
else {
continue;
}
}
else if (board.tile[enter_row][enter_col].revealed == '?') {
if (option_3(board, enter_row, enter_col)) {
break;
}
else {
continue;
}
}
else if (board.tile[enter_row][enter_col].revealed == '#') {
if (option_1(board, enter_row, enter_col)) {
reveal_board(board, enter_row, enter_col, 0);
break;
}
else {
continue;
}
}
else {
printf("This tile is already revealed.\n");
continue;
}
}
else {
continue;
}
}
if (check_win(board)) {
print_board(board);
printf("You Won!!\n");
exit (0); //end the program because the game is over and the user has lost
}
if (isgameover(board)) {
print_board(board);
printf("You Lost :(\n");
exit(0); //end the program because the game is over and the user has lost
}
return;
}
void reset_button_action(GameState * state) {
Mouse * mouse = &state->mouse;
Button * buttons = state->hud.buttons;
int i;
for (i = 0; i < BUTTON_AMOUNT; i++) {
if (in_bounds(mouse->screen_x, mouse->screen_y, buttons[i].bounds)) {
buttons[i].state = BUTTON_UP;
}
}
}
/* Find the next codel following the DP. next contains the current
* codel and will be changed. Return true if the codel is in the
* program.. */
static int get_next_codel_dp(struct codel *next)
{
switch(interp.dp) {
case 0: next->x++; break;
case 1: next->y++; break;
case 2: next->x--; break;
case 3: next->y--; break;
default: abort();
}
return in_bounds(next);
}
void nested_mpi::choose_step(){
double val=1;
do {
dice.generate_ellipse();
for (int i=0;i<nb_var;++i)
trial_vector[i]=dice.get_value(i)+ave_cov[i];
if (in_bounds(trial_vector) != -FLT_MAX)
if (log_prior(trial_vector) != -FLT_MAX)
if (log(statistics::random_2()) <= (log_prior(trial_vector))) val=0;
} while (val == 1);
}
bool quest_poison_drop_hook(char *fmt)
{
s32b mcnt = 0, i, x, y, o_idx;
object_type *o_ptr;
o_idx = get_next_arg(fmt);
o_ptr = &p_ptr->inventory[o_idx];
if (cquest.status != QUEST_STATUS_TAKEN) return FALSE;
if (p_ptr->wilderness_y != wild_locs[cquest.data[0]][0]) return FALSE;
if (p_ptr->wilderness_x != wild_locs[cquest.data[0]][1]) return FALSE;
if (p_ptr->wild_mode) return FALSE;
if (o_ptr->tval != TV_POTION2) return FALSE;
if (o_ptr->sval != SV_POTION2_CURE_WATER) return FALSE;
for (i = m_max - 1; i >= 1; i--)
{
/* Access the monster */
monster_type *m_ptr = &m_list[i];
/* Ignore "dead" monsters */
if (!m_ptr->r_idx) continue;
if (m_ptr->status <= MSTATUS_NEUTRAL) mcnt++;
}
if (mcnt < 10)
{
for (x = 1; x < cur_wid - 1; x++)
for (y = 1; y < cur_hgt - 1; y++)
{
if (!in_bounds(y, x)) continue;
if (cave[y][x].feat == FEAT_TAINTED_WATER) cave_set_feat(y, x, FEAT_SHAL_WATER);
}
cmsg_print(TERM_YELLOW, "Well done! The water seems to be clean now.");
cquest.status = QUEST_STATUS_COMPLETED;
del_hook(HOOK_DROP, quest_poison_drop_hook);
process_hooks_restart = TRUE;
return FALSE;
}
else
{
msg_print("There are too many monsters left to cure the water.");
return TRUE;
}
return FALSE;
}
struct cpi_disp_font *
cpi_get_disp_font (cpi_handle_t *handle,
struct cpi_entry *entry, int rows, int cols)
{
int i;
long p;
struct cpi_font_info *info;
struct cpi_disp_font *font;
if (!in_bounds (handle, entry->font_info_ptr))
{
ERROR ("cpi_get_disp_font: font info out of bounds!\n");
return NULL;
}
info = (struct cpi_font_info *) ((handle->font_is_nt ?
(void *) entry + sizeof (struct cpi_entry) :
handle->cpi_file + entry->font_info_ptr));
p = (long) info + sizeof (struct cpi_font_info);
for (i = 0; i < info->font_no; i++)
{
if (!in_bounds (handle, p - (long) handle->cpi_file))
{
ERROR ("cpi_get_disp_font: font 0x%lx (%d) out of bounds!\n",
p, i);
return NULL;
}
font = (struct cpi_disp_font *) p;
if (font->cols == cols && font->rows == rows)
return font;
p += sizeof (struct cpi_disp_font) +
BITS2BYTES (font->chars * font->rows * font->cols);
}
return NULL;
}
/* Function that sees if a square is a floor. (Includes range checking.) */
bool get_is_floor(int x, int y)
{
if (!in_bounds(y, x))
{
/* Out of bounds */
return (FALSE);
}
/* Do the real check */
if (is_floor_bold(y, x)) return (TRUE);
return (FALSE);
}
/*
* Builds the entire set of neighborlists for all particles during the first iteration
*
* arguments:
* particles: The spatially decomposed particle information
* neighbors: The array of all neighbor lists
* my_rank: The rank of the node
*/
void build_neighbor_lists_initial(Particle* particles[XDiv][YDiv][ZDiv], Neighbor** neighbors, int my_rank){
int x, y, z, i;
Particle p;
int tag = 0;
int rank = my_rank;
for (x = node_boundries[rank][0]; x <= node_boundries[rank][1]; ++x){
for (y = node_boundries[rank][2]; y <= node_boundries[rank][3]; ++y){
for (z = node_boundries[rank][4]; z <= node_boundries[rank][5]; ++z){
if(in_bounds(x, XDiv) && in_bounds(y, YDiv) && in_bounds(z, ZDiv)){
#pragma omp for private(p)
for (i = 0; i < block_size; ++i){
p = particles[x][y][z][i];
if (p.index != -1) {
build_list_full(particles, neighbors[tag + i], x, y, z, i);
}
}
tag = tag + block_size;
}
}
}
}
}
void set_button_hover_state(GameState * state) {
int i;
Button * buttons = state->hud.buttons;
Mouse * mouse = &state->mouse;
for (i = 0; i < BUTTON_AMOUNT; i++) {
if (in_bounds(mouse->screen_x, mouse->screen_y, buttons[i].bounds)) {
buttons[i].state = BUTTON_HOVER;
}
else {
buttons[i].state = BUTTON_UP;
}
}
}
/*
* Put trees near a hole in the dungeon roof (rubble on ground + up stairway)
* This happens in real world lava tubes.
*/
void place_trees(int x, int y)
{
int i, j;
cave_type *c_ptr;
/* place trees/ rubble in ovalish distribution */
for (i = x - 3; i < x + 4; i++)
{
for (j = y - 3; j < y + 4; j++)
{
if (!in_bounds(j, i)) continue;
c_ptr = &cave[j][i];
if (c_ptr->info & CAVE_ICKY) continue;
if (c_ptr->o_idx) continue;
/* Want square to be in the circle and accessable. */
if ((distance(j, i, y, x) < 4) && !cave_perma_grid(c_ptr))
{
/*
* Clear previous contents, add feature
* The border mainly gets trees, while the center gets rubble
*/
if ((distance(j, i, y, x) > 1) || (randint1(100) < 25))
{
if (randint1(100) < 75)
cave[j][i].feat = feat_tree;
}
else
{
cave[j][i].feat = feat_rubble;
}
/* Clear garbage of hidden trap or door */
c_ptr->mimic = 0;
/* Light area since is open above */
if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) cave[j][i].info |= (CAVE_GLOW | CAVE_ROOM);
}
}
}
/* No up stairs in ironman mode */
if (!ironman_downward && one_in_(3))
{
/* up stair */
cave[y][x].feat = feat_up_stair;
}
}
/*
* Create a feature near the player.
*/
static void do_cmd_wiz_feature(int feat)
{
int px = p_ptr->px;
int py = p_ptr->py;
int y, x, d = 3, attempts = 30;
while (1)
{
/* Find a location */
y = rand_spread(py, d);
x = rand_spread(px, d);
/* Reject illegal grids */
if (!in_bounds(y, x)) continue;
/* Reject the player */
if ((y == py) && (x == px)) continue;
attempts--;
if (!attempts)
{
d++;
attempts = 8 * d;
}
/* Try to place a new feature */
if (area(y, x)->feat == feat) continue;
/* Okay */
break;
}
/* Nuke objects */
delete_object_idx(area(y, x)->o_idx);
/* Nuke monsters */
delete_monster_idx(area(y, x)->m_idx);
/* Forget this grid */
area(y, x)->info &= ~(CAVE_MARK);
/* Place the feature */
cave_set_feat(y, x, feat);
/* Update stuff */
p_ptr->update |= (PU_VIEW | PU_MONSTERS | PU_MON_LITE);
}