Hexagonal Grid Rangefinding

Well, since you have a dynamic environment there's no way around checking each tile until you run out of movement points. However i would suggest to use a similar apporach to "A*", just that you don't have an actual target. So you would simply add your starting tile to an "open" list. When a tile is expanded you check all 6 neighbor tiles and add them to the open list. Once a tile is expanded you remove it from the openlist and add it to a "closed" list.

When checking the neighbor tiles you don't readd a tile that is already on the closed list. It's important that you sort your openlist by the "left over movement points" so that the tile with the most movement points left should be processed first. That ensures that you get the "best" way to each tile. For each tile you should save the remaining movement points, so when expanding to a neighbor you use that value as reference. The start tile should be initialized with your available movement points.

edit

Since we don't know how your grid data is actually stored we can only provide abstract pseudo code.

 List<Tile> GetNeighbors(Tile) // should return all 6 neighbors of the given tile.
 float GetCost(Tile) // should return the cost of that tile.
 
 List<Tile> openList = new List<Tile>();
 List<Tile> closedList = new List<Tile>();
 Dictionary<Tile, float> movementPoints = new Dictionary<Tile, float>();

 void ExpandTile(Tile aTile)
 {
     float parentPoints = movementPoints[aTile];
     closedList.Add(aTile);
     foreach (var tile in GetNeighbors(aTile))
     {
         if (closedList.Contains(tile) || openList.Contains(tile))
             continue;
         float points = parentPoints - GetCost(tile);
         if (points < 0)
         {
             // this tile is outside of the reachable area
             continue;
         }
         openList.Add(tile);
         movementPoints[tile] = points;
     }
 }

 void CalcRange(Tile aStartingTile, float aMovementPoints)
 {
     openList.Clear();
     closedList.Clear();
     movementPoints[aStartingTile] = aMovementPoints;
     ExpandTile(aStartingTile);
     while (openList.Count > 0)
     {
         openList.Sort((a,b)=> movementPoints[a].CompareTo(movementPoints[b]) );
         var tile = openList[openList.Count - 1];
         openList.RemoveAt(openList.Count - 1);
         ExpandTile(tile);
     }
 }

I've tested this with a normal x / y grid and it works as expected:

I added a "virtual" obstacle(cost >5000) on the lower left side and a "light" obstacle on the top left side (cost "3" instead of "1").

The yellow cubes are the grid positions that are outside the reachable area. The red cubes are the 5000+ obstacle and the rest are the movable tiles with a color faded according to their remaining movement points.