return (!is_damaging_cloud(ctype));

    return (!is_damaging_cloud(ctype, true));

    
    // item.base_type <-> char conversion table
    const static char *obj_syms = ")([/%#?=!#+\\0}x";
    

    const int cloud = env.cgrid[x][y];
    if (cloud != EMPTY_CLOUD)
    {
        const cloud_type ctype = env.cloud[ cloud ].type;
        // don't prompt if already in a cloud of the same type
        if (is_damaging_cloud(ctype, false)
            && (env.cgrid[you.x_pos][you.y_pos] == EMPTY_CLOUD
                || ctype != env.cloud[ env.cgrid[you.x_pos][you.y_pos] ].type))
        {
            std::string prompt = make_stringf(
                                    "Really step into that cloud of %s?",
                                    cloud_name(ctype).c_str());
            if (!yesno(prompt.c_str(), false, 'n'))
            {
                canned_msg(MSG_OK);
                you.turn_is_over = false;
                return (false);
            }
        }
    }

                if (! yes_or_no("Do you really want to step into the %s",
                                "Zot trap"))

                if (!yes_or_no("Do you really want to step into the Zot trap"))

            else if (type == TRAP_SHAFT && you.airborne())

            else if (new_grid != DNGN_TRAP_MAGICAL && you.airborne())

                // No prompt

                // No prompt (shaft and mechanical traps ineffective, if flying)

bool is_damaging_cloud(cloud_type type);

bool is_damaging_cloud(cloud_type type, bool temp = false);

bool is_damaging_cloud(cloud_type type)

bool is_damaging_cloud(cloud_type type, bool temp)

        return (!player_res_poison(false, false));

        return (!player_res_poison(false, temp));

        return (player_res_steam(false, false) <= 0);

        return (player_res_steam(false, temp) <= 0);

        return (player_prot_life(false, false) <= 2);

        return (player_prot_life(false, temp) <= 2);

        if (is_damaging_cloud(type))

        if (is_damaging_cloud(type, false))

}
static void _maybe_restart_fountain_flow(const int x, const int y, int tries)
{
     while (0 < tries--)
     {
          if (!one_chance_in(100))
              continue;
              
          if (grd[x][y] > DNGN_SPARKLING_FOUNTAIN)
              grd[x][y] = static_cast<dungeon_feature_type>(grd[x][y] - 1);
          else // grid == DNGN_DRY_FOUNTAIN_I
              grd[x][y] = DNGN_BLUE_FOUNTAIN;
          // clean bloody floor
          if (is_bloodcovered(x,y))
              env.map[x][y].property = FPROP_NONE;
              
          // chance of cleaning adjacent squares
          for (int i = -1; i <= 1; i++)
               for (int j =-1; j <= 1; j++)
               {
                    if (is_bloodcovered(x+i,y+j)
                        && one_chance_in(5))
                    {
                        env.map[x+i][y+j].property = FPROP_NONE;
                    }
               }
     }

            ASSERT(rot_time < 256);

            // potions of blood have a longer rot time
            if (it.base_type == OBJ_POTIONS)
                ASSERT(rot_time < 1500);
            else
                ASSERT(rot_time < 256);
                

        for (cx=0; cx<GXM; cx++)
        {
            for (cy=0; cy<GYM; cy++)

        for (cx = 0; cx < GXM; cx++)
            for (cy = 0; cy < GYM; cy++)

                if (grd[cx][cy] > DNGN_SPARKLING_FOUNTAIN
                    && grd[cx][cy] < DNGN_PERMADRY_FOUNTAIN)

                if (grd[cx][cy] == DNGN_DRY_FOUNTAIN_I
                    || grd[cx][cy] > DNGN_SPARKLING_FOUNTAIN
                       && grd[cx][cy] < DNGN_PERMADRY_FOUNTAIN)

                    for (int i=0; i<fountain_checks; i++)
                    {
                        if (one_chance_in(100))
                        {
                            if (grd[cx][cy] > DNGN_SPARKLING_FOUNTAIN)
                                grd[cx][cy] =
                                    static_cast<dungeon_feature_type>(
                                        grd[cx][cy] - 1);
                                        
                            // clean bloody floor
                            if (is_bloodcovered(cx,cy))
                                env.map[cx][cy].property = FPROP_NONE;
                            // chance of cleaning adjacent squares
                            for (int k=-1; k<=1; k++)
                            {
                                 for (int l=-1; l<=1; l++)
                                      if (is_bloodcovered(cx+k,cy+l)
                                          && one_chance_in(5))
                                      {
                                          env.map[cx+k][cy+l].property = FPROP_NONE;
                                      }
                            }
                        }
                    }

                    _maybe_restart_fountain_flow(cx, cy, fountain_checks);

        }

    case DNGN_DRY_FOUNTAIN_III:

    case DNGN_DRY_FOUNTAIN_V:

show_items = !?/%=([)X}+\_.
# title_screen = false

tile_show_items = !?/%=([)X}+\_.
# tile_title_screen = false