Is “Willingly” an actual game term? [duplicate]

Booming Blade says the following:

If the target willingly moves 5 feet or more before (the start of your next turn), the target takes 1d8 thunder damage, and the spell ends.

Is “willingly” an actual game term? Or is it just meant to be taken for the obvious meaning, that being compelled to move magically, or being shoved doesn’t count?

What are some other examples of “Willingly” being used in D&D?

What is a “game term”?

These two questions use the phrase "game term":

  • Is “a special melee attack” an actual game term?
  • What does ‘ally’ mean, as a game term?

Both answers seem to make a distinction between game terms and regular English, but what exactly does it mean for a word or phrase to be a "game term"?

Note, there are many other examples of Q&As that make this distinction, see these search results for more.

Is “a special melee attack” an actual game term?

PHB page 195 mentions "special melee attack" when talking about Grapple and Shove:

you can make a special melee attack to shove a creature

you can use the Attack action to make a special melee attack, a grapple

It uses words "make a special melee attack" like it is a thing in 5e, however, nowhere in the game text it’s being said what a "special melee attack" actually is. It isn’t even mentioned anymore. I believe that "special attack" is not a game term — it’s a vestige from the previous editions, where "special attacks" was a thing, but I could be mistaken.

Are there any other examples of "special melee attack" (or just "special attack") in any official source book for 5e?

I was searching through dndbeyond and the only thing I’ve found was Sword Of Answering. But it uses words "special attack" in the context of the magic item description:

while you hold the sword, you can use your reaction to make one melee attack

any damage dealt with this special attack ignores any damage immunity or resistance the target has

You can remove the word "special" from its description and nothing changes. So it is plain English meaning here, not the game term.

So what is a "special attack" in terms of the game mechanics?

Add term of current custom post type to admin body class using admin_body_class

I am trying to add the current custom post type term to the body class of my WordPress admin page. So when I am viewing an existing custom post type that has been assigned a term it will add that term to the body class.

I have found the following code but cannot get it to work for me:

add_filter( 'admin_body_class', 'rw_admin_body_class' ); function rw_admin_body_class( $  classes ) {     if ( 'post' != $  screen->base )         return $  classes;      global $  post;     $  terms = wp_get_post_terms( $  post->ID, 'product_cat', array( 'fields' => 'all' ) );     $  terms = wp_list_pluck( $  terms, 'slug' );     foreach ( $  terms as $  term )     {         $  classes .= ' my_taxonomy-' . $  term;     }      return $  classes; } 

Any pointers on how to get this working?

using Guidance and Resistance for long term effects

The Guidance and Resistance cantrips both last for 1 minite, but a lot of saves and checks represent longer stretches of time, and I want to know if those cantrips can be applied in those situations.

For instance, can a creature on watch benefit from Guidance for their Wisdom (Perception) roll?

Can a creature traveling for extra hours in the day benefit from Resistance for their Constitution save to prevent exhaustion?

Termination of term rewiting using strict partial order on subterms

Are there any good books, research reports, surveys, theses, or papers that display proof techniques, with clear proofs of termination of term rewriting problems that have the following form…?

Terms are represented by directed acyclic graphs where the terms are vertices with arcs labelled $ arg_{1}…arg_{n}$ pointing to the immediate sub-terms. There would be additional equality arcs between vertices. Thinking of the transitive closure of the equality arcs as representing equivalence classes of vertices that are "merged", the $ arg$ arcs in the graph form a lattice (because or the strict order on sub-terms, and some sub-terms might be shared). A rewrite rule would add extra arcs, such that existing partial order would be preserved and added to, so the rewrite rules would be constructing a series of partial orders (represented in the graph state at each step) $ p_{0} \subset … \subset p_{m}$ more and more "constraining" the partial order relation between vertices until either the re-write rules find nothing to re-write or a rewrite would introduce a cycle (immediately detectable by a depth first search). I think this kind of termination proof is correct because we can say every step was a reduction under the partial order $ p_{m}$ but I’d like a formal justification because I have worries about my not knowing $ p_{m}$ before hand, only when it is constructed. And if the rewrite finds a cycle then that cycle was implicit from the beginning. Again I think that’s OK because my re-write rules are prove-ably LHS iff RHS so they transform the problem to an equivalent problem. I call this "construct a partial order or die trying." Is there a more formal name for this kind of proof?

Ideally the proof examples would be constructive and mathematically thorough. I see some papers that assume a lot of prior knowledge, probably because of brevity requirement, and not wanting to bore an expert audience. And others with "wordy" explanations, which are great to give intuitive understanding, but proofs should not depend on them.

What is the “continuity” as a term in computable analysis?


Background

I once implemented a datatype representing arbitrary real numbers in Haskell. It labels every real numbers by having a Cauchy sequence converging to it. That will let $ \mathbb{R}$ be in the usual topology. I also implemented addition, subtraction, multiplication, and division.

But my teacher said, "This doesn’t seem to be a good idea. Since comparison is undecidable here, this doesn’t look very practical. In particular, letting division by 0 to fall in an infinite loop doesn’t look good."

So I wanted my datatype to extend $ \mathbb{Q}$ . Since equality comparison of $ \mathbb{Q}$ is decidable, $ \mathbb{Q}$ is in discrete topology. That means a topology on $ \mathbb{R}$ must be finer than the discrete topology on $ \mathbb{Q}$ .

But, I think I found that, even if I could implement such datatype, it will be impractical.

Proof, step 1

Let $ \mathbb{R}$ be finer than $ \mathbb{Q}$ in discrete topology. Then $ \{0\}$ is open in $ \mathbb{R}$ . Assume $ + : \mathbb{R}^2 → \mathbb{R}$ is continuous. Then $ \{(x,-x): x \in \mathbb{R}\}$ is open in $ \mathbb{R}^2$ . Since $ \mathbb{R}^2$ is in product topology, $ \{(x,-x)\}$ is a basis element of $ \mathbb{R}^2$ for every $ x \in \mathbb{R}$ . It follows that $ \{x\}$ is a basis element of $ \mathbb{R}$ for every $ x \in \mathbb{R}$ . That is, $ \mathbb{R}$ is in discrete topology.

Proof, step 2

Since $ \mathbb{R}$ is in discrete topology, $ \mathbb{R}$ is computably equality comparable. This is a contradiction, so $ +$ is not continuous, and thus not computable.

Question

What is bugging me is the bolded text. It is well-known that every computable function is continuous (Weihrauch 2000, p. 6). Though the analytic definition and the topological definition of continuity coincide in functions from and to Euclidean spaces, $ \mathbb{R}$ above is not a Euclidean space. So I’m unsure whether my proof is correct. What is the definition of "continuity" in computable analysis?

What is the term for data leaking from one HTTP request to another and how to prevent it?


Context

We recently added a feature that used a library whose API we misunderstood. Long story short, if user A sends a request to our web application, the library caches some result, and that result may show in a response to user B’s request. Needless to say, this is a security bug, specifically, data from user A leaks to user B.

Although it is well-known that web application should be stateless, the long dependency graph of such application makes the likelihood of some downstream library (or its bad usage) accidentally leaking data between requests non-zero. I can imagine this bug is possible with a wide range of web frameworks and environments (e.g., Django, .NET, NodeJS, AWS Lambda), since they all reuse the application between request to avoid cold starts.

Questions

  1. What is the proper term for data leaking server-side between HTTP requests, due to an honest developer mistake? Terms such as session hijacking and session fixation seem to refer exclusively to malicious attacks.

  2. Are there tools and method to test for such mistakes or detect them in production?