## Are There 3D Rules for Flying and Distance?

I recently had a problem come up in a session that I wanted to see if there was more information on. On of my players recently gained the ability to fly on his flame cleric and wanted to use his warding flare on an ally while flying.

He was 30 feet up and 20 feet out, and when I calculated the distance between him and the target it should have been about 35, so I thought he was out of range.

He argued that in dnd it shouldn’t matter so long as he is not more than 30 feet out, and 30 feet higher than the target. Which means his 30 ft ability can extend to 42 feet total.

I allowed it because it wasn’t a big deal at the time, and I would just spend time looking for the rules after the session, but I haven’t found any. Are there any good clarifications on 3D situations such as these?

Quick edit for the ability effect: Warding Flare allows you to target an attacking enemy you can see that is within 30 ft of you using your reaction, and give them disadvantage on an attack. It can be used a number of times equal to your wisdom mod.

## At what area and distance can a character detect a trap?

At what area and distance can a character detect a trap when actively searching? And on which with passive.

Hypothetically. Suppose that in front of the character is a corridor 30 squares long and 3 squares wide. There are five traps in the corridor, each 3 square wide and 1 square long. The player assumes that there are traps in the corridor and begins to actively search for them. How many traps and how far is he able to spot?

And exactly the same question but if the character is not looking for traps relying only on passive perception.

## Compare two plots by finding the minimum distance among points

I have a question about comparing the points within two plots. I would like to compare two plots and find the minimum distance among their points, in order to find the nearest/common points (i.e. those ones with minimum -or zero-distance) and plot it (overlapping). What I did is to extract the coordinates of their respectively points. But I do not know how to compare them and/or the two plots. I used the following line of code, but the result is completely different from what I am looking for.

Outer[EuclideanDistance, seq1, seq2, 1] // Flatten 

## Maximum and Minimum distance from query point within bounding box

I’m reading an article regarding approximating sums using KD-trees (similar to FMM).

As part of the effort I’m trying to make sense of this article , which is cited.

I’m having trouble understanding this part:

Computing the maximum variation of weights over all points below node ND is easy. We know the location of xquery and we know the bounding hyperrectangle of the current node. A simple algorithm costing O(Number of tree dimensions) can compute the shortest and largest possible distances to any point in the node. From these two values, and the assumption that the weight function is non-increasing, we can compute the minimum and maximum possible weights wmin and wmax of any datapoint below node ND.

The only solution I can think of is to bound the variation (wmax-wmin) from above using the four corners of the bounding box, and then computing the distance from the query point to each of the four corners is indeed O(d). But this doesn’t seem to be the author’s intention. Could anybody point me to what I”m missing here?

## Extracting a spanning tree from a directed acyclic graph with minimum total distance between terminal nodes

I have a directed acyclic graph that has uniform edge weights. I would like to extract from this graph a spanning tree (an arborescence) with the property that the total distance between all pairs of leaf nodes (the sum of combined distances from each pair’s nearest common ancestor) is minimized.

What I’m ultimately trying to accomplish is to find the best way of ordering the leaf nodes in such a way that the most closely related nodes are closest to each other in the list. If I can find the spanning tree as described, I can easily order the leaf nodes in the way I need.

Can anyone point me to a solution to this problem other than just brute force optimization?

## can a grapple be released by the grappler at any distance within it’s reach

I have a creature that has a 15′ reach. It’s attack can also grapple. Currently it’s grappling a creature with a 5′ reach.

1. Can the grappled creature always attack the creature that is grappling it, even if it’s held at 10′?
2. Can the creature that’s grappling the other creature choose to let it go anywhere within it’s 15′ reach?
3. Does releasing the creature allow for an oppertuniy attack if the creature being released has a reaction? Even if it’s released at 15′? (if this is possible)
4. What sort of action is required for releasing a creature? A bonus action?

## How could I calculate the distance between the parent and neighbors node when there is a line of sight between two points?

I have completed my Astar algorithm in Python and now I need to convert it to a Theta star algorithm, I have built my line of sight algorithm below, but when I come to my Theta star algorithm I face some problems when there is a line of sight by calculating the distance and how could I make it jump the points that have line of sight. After running my code, I see there is no any effect, I see it’s working as Astar algorithm. Any assistance, please?

The snippet that I have a problem with it:

sight = lineOfsight(grid, y, x, y2, x2) if sight == True:          g2 = g + delta[i][2] + math.sqrt((x2 - x)**2 + (y2 - y)**2)           h2 = math.sqrt((x2 - goal[0])**2 + (y2 - goal[1])**2)           f2 = g2 + h2   else:           g2 = g + delta[i][2]                       h2 = math.sqrt((x2 - goal[0])**2 + (y2 - goal[1])**2)           f2 = g2 + h2   open.append([f2,g2,h2,x2,y2]) 

My line of sight code:

def lineOfsight(grid, y1, x1, y2, x2):     y_size = len(grid)     x_size = len(grid)      #Distance     dy=y2-y1     dx=x2-x1      if dy < 0:         dy = -dy         sy = -1     else:         sy = 1      if dx < 0:         dx = -dx         sx = -1     else:         sx = 1      f = 0      if dx >= dy:         while x1 != x2:             f = f + dy             if f >= dx and 0 < y1+(sy-1)/2 and y1+(sy-1)/2 < y_size and 0 < x1+(sx-1)/2 and x1+(sx-1)/2 < x_size:                 if grid[x1+int((sx-1)/2)][y1+int((sy-1)/2)]:                      return False                 y1 = y1 + sy                 f  = f  - dx              elif 0 < y1+(sy-1)/2 and y1+(sy-1)/2 < y_size and 0 < x1+(sx-1)/2 and x1+(sx-1)/2 < x_size:                 if f != 0 and grid[x1+(sx-1)/2][y1+(sy-1)/2]:                      return False              elif 1<y1 and y1<y_size and 0 < x1+(sx-1)/2 and x1+(sx-1)/2 < x_size:                 if dy==0 and grid[x1+int((sx-1)/2)][y1] and grid[x1+int((sx-1)/2)][y1-1] :                      return False             x1 = x1 + sx      else:          while y1 != y2:             f = f + dx             if f >= dy and 0 < y1+(sy-1)/2 and y1+(sy-1)/2 < y_size and 0< x1+(sx-1)/2 and x1+(sx-1)/2 < x_size:                 if grid[x1+int((sx-1)/2)][y1+int((sy-1)/2)]:                      return False                 x1 = x1 + sx                 f = f - dy             elif 0 < y1+(sy-1)/2 and y1+(sy-1)/2 < y_size and 0 < x1+(sx-1)/2 and x1+(sx-1)/2 < x_size:                 if f !=0 and grid[x1+int((sx-1)/2)][y1+int((sy-1)/2)]:                      return False              elif 0 < y1+(sy-1)/2 and y1+(sy-1)/2 < y_size and 1 < x1 and x1 < x_size:                        if dx == 0 and grid[x1][y1+ int((sy-1)/2)] and grid[x1-1][y1+int((sy-1)/2)]:                      return False              y1=y1+sy      return True 

My theta star code:

import matplotlib.pyplot as plt from lineofsightss import * #grid format # 0 = navigable space # 1 = occupied space  import random import math  grid = [[0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],         [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0],         [0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],         [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]]    init = [0,0]                            #Start location is (5,5) which we put it in open list. goal = [len(grid)-1,len(grid[0])-1]       heuristic = [[0 for row in range(len(grid[0]))] for col in range(len(grid))] for i in range(len(grid)):         for j in range(len(grid[0])):                     heuristic[i][j] = abs(i - goal[0]) + abs(j - goal[1])  plt.plot(0,10) plt.plot(0,-len(grid)-10) plt.grid(True) plt.axis("equal")  plt.plot([-1, len(grid[0])],[[-x/2 for x in range(-1,len(grid)*2+1)], [-y/2 for y in range(-1,len(grid)*2+1)]], ".k") plt.plot([[x/2 for x in range(-2,len(grid[0])*2+1)],[x/2 for x in range(-2,len(grid[-1])*2+1)]],[1, -len(grid)],".k")  plt.plot(init[1],-init[0],"og") plt.plot(goal[1],-goal[0],"ob")   #Below the four potential actions to the single field   delta =      [[1, 0, 1],               [0, 1, 1],               [-1, 0, 1],               [0, -1, 1],               [-1, -1, math.sqrt(2)],               [-1, 1, math.sqrt(2)],               [1, -1, math.sqrt(2)],               [1, 1, math.sqrt(2)]]    delta_name = ['V','>','<','^','//','\','\','//']   def search():      pltx,plty=[],[]     #open list elements are of the type [g,x,y]      closed = [[0 for row in range(len(grid[0]))] for col in range(len(grid))]     action = [[-1 for row in range(len(grid[0]))] for col in range(len(grid))]     #We initialize the starting location as checked     closed[init[0]][init[1]] = 1     expand=[[-1 for row in range(len(grid[0]))] for col in range(len(grid))]      # we assigned the cordinates and g value     x = init[0]     y = init[1]     g = 0      h = math.sqrt((x - goal[0])**2 + (y - goal[1])**2)      f = g + h      #our open list will contain our initial value     open = [[f, g, h, x, y]]       found  = False   #flag that is set when search complete     resign = False   #Flag set if we can't find expand     count = 0      #print('initial open list:')     #for i in range(len(open)):             #print('  ', open[i])     #print('----')      while found is False and resign is False:          #Check if we still have elements in the open list         if len(open) == 0:    #If our open list is empty, there is nothing to expand.             resign = True             print('Fail')             print('############# Search terminated without success')             print()         else:             #if there is still elements on our list             #remove node from list             open.sort()             #sort elements in an increasing order from the smallest g value up             open.reverse()          #reverse the list             next = open.pop()       #remove the element with the smallest g value from the list             #print('list item')             #print('next')              #Then we assign the three values to x,y and g. Which is our expantion.             x = next[3]             y = next[4]             g = next[1]             #elvation[x][y] = np.random.randint(100, size=(5,6))             expand[x][y] = count             count+=1              #Check if we are done             if x == goal[0] and y == goal[1]:                 found = True                 print(next) #The three elements above this "if".                 print('############## Search is success')                 print()              else:                 #expand winning element and add to new open list                 for i in range(len(delta)):       #going through all our actions the four actions                     #We apply the actions to x and y with additional delta to construct x2 and y2                     x2 = x + delta[i][0]                     y2 = y + delta[i][1]                       #if x2 and y2 falls into the grid                     if x2 >= 0 and x2 < len(grid) and y2 >=0 and y2 <= len(grid[0])-1:                          #if x2 and y2 not checked yet and there is not obstacles                         if closed[x2][y2] == 0 and grid[x2][y2]==0:                              sight = lineOfsight(grid, y, x, y2, x2)                             if sight == True:                                  g2 = g + delta[i][2] + math.sqrt((x2 - x)**2 + (y2 - y)**2)                                  h2 = math.sqrt((x2 - goal[0])**2 + (y2 - goal[1])**2)                                  f2 = g2 + h2                             else:                                  g2 = g + delta[i][2]                                              h2 = math.sqrt((x2 - goal[0])**2 + (y2 - goal[1])**2)                                  f2 = g2 + h2                              open.append([f2,g2,h2,x2,y2])                             #we add them to our open list                             pltx.append(y2)                             plty.append(-x2)                             #print('append list item')                             #print([g2,x2,y2])                             #Then we check them to never expand again                             closed[x2][y2] = 1                             action[x2][y2] = i      for i in range(len(expand)):         print(expand[i])     print()     policy=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))]     x=goal[0]     y=goal[1]     policy[x][y]='*'     visx = [y]     visy = [-x]     while x !=init[0] or y !=init[1]:         x2=x-delta[action[x][y]][0]         y2=y-delta[action[x][y]][1]         policy[x2][y2]= delta_name[action[x][y]]         x=x2         y=y2         visx.append(y)         visy.append(-x)     for i in range(len(policy)):         print(policy[i])     print()          plt.plot(visx,visy, "-r")      plt.show()  search() 

Here is below my output:

## Why do scrollbars revert to original scroll distance when mouse is dragged sideways too far?

When dragging the scrollbar using the mouse, the contents of the scrollpane move up and down as the bar moves with the mouse. But if you keep the mouse button held down, and move the pointer sideways for about 100 pixels (tested on Windows machines), the scrollbar goes back to its location before being dragged, and the scrollpane with it. Moving the mouse closer again will make the scrollbar follow the mouse again. Is there any benefit or explanation for this behaviour from a UX point of view?

## Is there a metric or distance of two languages?

Given a language $$L$$, I am finding a method to evaluate the advantage of an automaton to decide $$L$$.

My goal is to decide a language $$L$$ (and maybe it is not decidable for automata). If one constructs an automaton $$A_{1}$$ whose laguage is $$L_{1}$$, I want to know the advantage of $$A_{1}$$ for decisidng $$L$$. If there is a distance or metric of two languages $$d(\cdot, \cdot)$$, I can define $$\mathrm{Adv}_{L}(A_{1}) = d(L_{1}, L)$$. Thus, we can say $$A_{1}$$ is better than $$A_{2}$$ respect of $$L$$ if $$\mathrm{Adv}_{L}(A_{1}) > \mathrm{Adv}_{L}(A_{2})$$.

In my opinion, the follow conditions are satisfied at least.

1 It is non-negativity and identity of indiscernibles, $$d(L_{1}, L_{2}) \geq 0 ~\text{iff}~L_{1} = L_{2}$$.

2 It is symmetry, $$d(L_{1}, L_{2}) = d(L_{2}, L_{1})$$.

3 If $$L_{1} \cap L \subseteq L_{2} \cap L$$ and $$L_{1} \setminus L = L_{2} \setminus L$$, then $$d(L,L_{1}) \leq d(L,L_{2})$$.

4 If $$L_{1} \cap L = L_{2} \cap L$$ and $$L_{1} \setminus L \subseteq L_{2} \setminus L$$, then $$d(L,L_{1}) \geq d(L,L_{2})$$.

## For object fall damage, does the 20d6 maximum apply only to the additional damage from distance, or is it an overall maximum?

According to the DMG, page 303:

For each 200 pounds of an object’s weight, the object deals 1d6 points of damage, provided it falls at least 10 feet. Distance also comes into play, adding an additional 1d6 points of damage for every 10-foot increment it falls beyond the first (to a maximum of 20d6 points of damage).

I read this to mean that the damage added by the distance of the fall caps at 20d6, but the damage based on the weight of the object doesn’t have a cap.

A friend of mine says that remembers a lot of discussion on the topic years ago, and remembers a ruling that the damage that a falling object deals has a hard cap of 20d6, regardless of additional weight.

Unfortunately, he can’t find where the stuff he remembers was said, and so all we have to go on is the text in the book. Does anyone know what the proper right answer is? Preferably with a source?