It will always depend on how the whole map structure is designed and programmed. I most of the time will use a 2D array (or nested lists as in python) to represent a map, each entry will be a tile you can step on. That of course is only cool as long as the maps don't become too large, because thousands and thousands of living objects within a 2D array will take up a good amount of space which doesn't actually need to be there, it always depends on your need. Now imagine me wanting to know if there is a wall left of me, thus checking the x-axis to the left from the player's current position, and how far left it is from me. Imagine python code like this:

player_x = 5
player_y = 2
# imagine there is a wall 2 tiles away from me to the left, so at x = 3
distance = 0
i = player_x # we don't need to check all tiles further right, because we're checking for the left wall
for i in range(player_x, -1, -1):
  # we need to assume you know any way of type checking, like checking if objects are of the same kind, or adding a Type property to it or whatever, so just imagine this check getting applied in the if below
  if map[i][player_y] is Wall:
    distance = player_x - i
    break

In this case, distance would tell you the tiles to reach the wall. If it's zero, no wall could be found left from you. If you're now designing a radar, you'd like to implement a limit, as the radar will probably only check like 10 tiles from your current position, so you don't need to look further left than 10 tiles. Thats pretty easily done by adjusting the for loop:

radar_range = 10

# max will return the larger value. it ensures that you won't try to access negative indices within your map
for i in range(player_x, max(player_x - radar_range, 0), -1):
  # all the stuff from above
  pass

I hope that clarifies things. Over all, that kind of feature is not actually very hard to implement.
Best Regards.
Hijacker

hello
What you are looking for, is something called raycasting
Basically, you have 4 ray scans. 1 to y in front, 1 to y behind, 1 to left, 1 to right
check for walls and play wall sounds accordingly, whenever the character moves.
Imagine it like a shadow following your character in this case 4 shadows.

The new unfinished version of danger on the wheel does it and it works quite nicely.

hth

The difference is that you don't scan per say, instead of moving only your character, you move 5 characters: your character and four pointers, one for each direction, at a certain distance. Because when you move left, you don't need to rescan tiles you already scanned the move before. However, you need to rescan the axis perpendicular to your movement. At least, that's what I understood from post 4.

However, I have another solution if you are not memory-bound and would prefer have better performance. Since the map is static, you can preprocess all that data and add it to the map data. This way, at runtime you just have to check the new tile your character is standing on and that's it. I don't know the feature you want, but say you want the distance of the closest wall from a tile in all directions, then add 4 fields to every tile: distWallLeft, distWallTop, distWallRight, distWallBottom. Then when you character moves on a tile, lookup those properties and if the value is under a treshold, play a sound or something.

If you stored your map differently, like a list of game objects, you still can burn that data in the map representation if you think about it, but it's always gonna be more memory, it's a tradeoff.