Is the telepathy rule in the Monster Manual only applicable to monster telepathy abilities?

In the Monster Manual, in the chapter “Monster Statistics” it says:

Telepathy Telepathy is a magical ability that allows a monster to communicate mentally with another creature within a specified range. The contacted creature doesn’t need to share a language with the monster to communicate in this way with it, but it must be able to understand at least one language. A creature without telepathy can receive and respond to telepathic messages but can’t initiate or terminate a telepathic conversation.

A telepathic monster doesn’t need to see a contacted creature and can end the telepathic contact at any time. The contact is broken as soon as the two creatures are no longer within range of each other or if the telepathic monster contacts a different creature within range. A telepathic monster can initiate or terminate a telepathic conversation without using an action, but while the monster is incapacitated, it can’t initiate telepathic contact, and any current contact is terminated. (MM p.9)

Are these rules intended only to apply to monster telepathic abilities?

Specifically, when it says

A creature without telepathy can receive and respond to telepathic messages but can’t initiate or terminate a telepathic conversation.

Does it mean that characters can respond to “a monster’s telepathic messages” or “telepathic messages from any source”?

Several Jeremy Crawford rulings seem to imply that the intent is for this to apply only to monster telepathy (see here and here for example). However, I’ve seen this cited in arguments that have nothing to do with monster telepathy as well (see this answer). So I just want a clear answer as to what case this section of the rules applies to.

Rewrite rule for changing permalinks. Post name to permalink with Category


  1. I have an wordpress site that has existing posts.

  2. Permalink structure is currently configured to

  3. I need to change the Permalink structure to but when I save these settings results to 404 does not redirect to

  4. When I remove the /%category%/ and just use the 301 redirection from works fine

Is there a better way to achieve changing to with proper redirections from

Note: I already deactivate all plugins and just used the default twentytwenty theme. I have 11,000 existing posts.

SCENARIO B (if Scenario A does not work or there is no solution to Scenario A. Im looking at option Scenario B)

  1. The existing posts are under a category called "Local News", "local-news"
  2. Is there a way where I can just filter the rewrite rule so that if a post is under "Local News" category then the permalink structure will be then all other new posts will follow the main permalink structure I have set which is ?

Currently I have this but I’m not sure it’s working properly. When I apply this it seems to work for posts that are under "Local News" category. However it breaks my PAGES. PAGES result in 404s.

function custom_permalink( $  permalink, $  post, $  leavename ) {     // Get the category for the post     $  category = get_the_category($  post->ID);     if (  !empty($  category) && $  category[0]->cat_name == "Local News" ) {         $  cat_name = strtolower($  category[0]->cat_name);         $  permalink = trailingslashit( home_url('/' . $  post->post_name .'/' ) );     }     return $  permalink; }  add_action( 'init', 'custom_rewrite_rules' ); function custom_rewrite_rules() {     add_rewrite_rule(         '([^/]+)(?:/([0-9]+))?/?$  ',         'index.php?category_name=local%news&name=$  matches[1]&page=$  matches[2]',         'top' // The rule position; either 'top' or 'bottom' (default).     ); } 

Is this a correct approach or is my code correct? I’m also not sure if the rewrite rules I made affects other things. Basically I just want to retain permalink/url of the old posts and moving forward I want to follow the new permalink settings. I’m avoiding old posts to result in 404 pages.


Does the Monstrous Combat Options rule of breath weapons scaling with creature size apply to PC’s?

While discussing build options with a fellow party member (an Alchemist), they mentioned a rule granting breath weapons increased area when the user increases size category. After a bit of searching, I was able to find the rule in question:

Breath Weapon: The monster gains a breath weapon that deals 1d6 points of damage + 1d6 per CR. A target can attempt a Reflex saving throw to take half damage. If the breath weapon is a cone, it’s 30 feet long, increasing by 10 feet for each size category above Medium, and decreasing by 5 feet for every size category below Medium. If the breath weapon is a line, its area of effect is twice as long as a cone would be.

However, said rule was located in a section about monster creation/advancement, and now we’re debating whether or not it applies to PC’s changing size due to spells or buffs. Is there any other RAW indication whether or not gaining or losing a size category would generally affect breath weapon areas in this manner, or would this ultimately be a matter of GM fiat?

Does Tiamat rule over lesser devils?

I am in a situation where the Cult of the Dragon is in direct conversation with a bearded devil that wishes to wreak havoc on their camp. (It’s a long story that I’m happy to provide details with if asked)

However, my question is this: Although Tiamat is no longer an archdevil and only resides within Avernus of the Nine Hells, does she have any control in this situation to tell the bearded devil to step off? I have my own thoughts, but I’m curious to start a discussion on it.

How do I approach towards an abstract production rule interpreter with this situation of converting XML to python or java class?

If I am asking in the wrong place, please forgive and direct me to a more suitable one

So I have a XML like this

<range>    unconstrained    <span>       <rttype>          String </range>  <range>    x type    <span>       <rttype>          int       <assert>          $   > 0 </range>  <range>    Simple class reference    <span>       <rttype>          SimpleClass </range>  <range>    Simple class set    <span>       <rttype>          ArrayList<SimpleClass> </range>  <class>   Simple class     <attribute>      x         <range>            x type   </attribute>    <attribute>      state   </attribute>    <action>      initializer      <guarantees>         x has been set to zero      </guarantees>      <pimaction>         .@a x @ = 0      </pimaction>   </action>    <action>      update x      <parameter>         new x         x type      <guarantees>         x has been set to new x      </guarantees>      <pimaction>         .@a x @ = @i new x @      </pimaction>   </action>    <state>      Exists   </state>    <state>      Doesn't exist   </state>    <event>      <<new>>   </event>    <event>      <<destroy>>   </event>    <event>      update   </event>    <transition>      Doesn't exist      <<new>>      Exists      <transitionaction>         initializer   </transition>    <transition>      Exists      <<destroy>>      Doesn't exist   </transition>    <transition>      Exists      update      Exists      <transitionaction>         update x   </transition> 

I have a Java compiler (let’s call this ToJavaCompiler) that will compile this into a Java class

And another Java compiler (let’s call this ToPythonCompiler) that will also compile this into a Python class.

class SimpleClass:      # State Enum Declaration     # see MMClass.ruleStateEnumDeclaration for implementation      SimpleClass_states = Enum("SimpleClass_states", "EXISTS DOESNTEXIST")      # Attribute instance variables     # see MMClass.ruleAttributeInstVarList for implementation      _x: int     _state: SimpleClass_states      # Class level attribute     # All class members accessor      SimpleClassSet: ClassVar[List[SimpleClass]] = []       # Constructor     # See MMClass.ruleConstructorOperation      # See constructEvent.ruleConstructorOperation     def __init__(self):         # requires         #    none         # guarantees         #    --> x has been set to zero and state == Exists         self._initializer()         self._state = SimpleClass.SimpleClass_states.EXISTS         SimpleClass.SimpleClassSet.append(self)      # Attribute getters      @property     def x(self) -> int:         # requires         #   none         # guarantees         #   returns the x         return self._x      @property     def state(self) -> SimpleClass_states:         # requires         #   none         # guarantees         #   returns the state         return self._state       # Pushed events      def destroy(self) -> None:         # requires         #    none         # guarantees         #   state was Exists --> state == Doesn't exist         if self._state == SimpleClass.SimpleClass_states.EXISTS:             self._state = SimpleClass.SimpleClass_states.DOESNTEXIST             SimpleClass.SimpleClassSet.remove(self)      def update(self, new_x: int) -> None:         # requires         #    none         # guarantees         #   state was Exists --> x has been set to new x         if self._state == SimpleClass.SimpleClass_states.EXISTS:             self._update_x(new_x)      # Private transition actions      def _initializer(self):         # requires         #   none         # guarantees         #   x has been set to zero         self._x = 0      def _update_x(self, new_x: int):         # requires         #   none         # guarantees         #   x has been set to new x         self._x = new_x 

THe thing is my production rule need access to instance variable data from the model object they are compiling.

For example to generate the instance variables declarations i need a production rule that’s written in Java code like this which require access to the underlying model itself at Context.model()

public void ruleAttributeInstVarList() {     // description     // this rule emits the set of (private) instance variable declarations, if any     //     // Class.#ATTRIBUTE_INST_VAR_LIST -->     // foreach anAttribute in class     // anAttribute.#DEFINE_INST_VAR     //     // requires     // none     // guarantees     // all attributes of this class have been declared as instance variable of the     // PIM Overlay run-time type     if (Context.model().isVerbose()) {         Context.codeOutput().indent();         Context.codeOutput().println("# Attribute instance variables");         Context.codeOutput().println("# see MMClass.ruleAttributeInstVarList for implementation");                  Context.codeOutput().println("");         if (!attributeSet.isEmpty()) {             for (Attribute anAttribute : attributeSet) {                 anAttribute.ruleDefineInstVarAsPrivate();             }         } else {             if (Context.model().isVerbose()) {                 Context.codeOutput().indent();                 Context.codeOutput().println("# none");             }         }         Context.codeOutput().indentLess();     } else {         for (Attribute anAttribute : attributeSet) {             anAttribute.ruleDefineInstVarAsPrivate();         }     }     Context.codeOutput().println("");     Context.codeOutput().println(""); } 

I wonder if there’s an easier way to add target languages or frameworks without creating separate codebases per target language.

For e.g. I now have a ToJavaCompiler and a ToPythonCompiler two separate codebases

So I am here asking if there’s a way I can create an abstract production rule interpreter that suits my needs. My aim is to ultimately produce model classes in the target language or framework (such as Django or Rails) with a single codebase that allows extensions for different target languages/frameworks

I am okay to move away from Java if there’s a better language that suits what I am trying to do.

Does D&D 5e have a rule for character knowledge about monsters?

In the 3rd and 4th editions of D&D, there were explicit rules for determining if a character knew anything about a monster before them. In 3rd edition, for example, use of the Knowledge skill with a general DC of 10 + the monster’s HD allowed for determining one fact, plus one fact per 5 points over the check.

Looking at the Intelligence section of the 5e PHB, I don’t see any similar notation. Does 5e provide any guidance as to when a player could use their out-of-game knowledge about a monster, or when the player might be told things their character would probably know in-game?

Is my understanding of strictness correct in this proof of a `foldl` rule?

Exercise G in Chapter 6 of Richard Bird’s Thinking Functionally with Haskell asks the reader to prove

foldl f e . concat  =  foldl (foldl f) e 

given the rule

foldl f e (xs ++ ys)  =  foldl f (foldl f e xs) ys 

There’s no mention whether the given rule applies to infinite lists, nor does the answer in the book mention infinite lists. If my reasoning is correct, they are indeed both valid for infinite lists, provided f is strict.

The undefined case for the given rule requires this additional proof:

-- f is strict  ⟹  foldl f is strict  (i.e., foldl f undefined = undefined)        foldl f undefined xs       =        undefined xs  -- case undefined       foldl f undefined undefined         undefined undefined --   =  {foldl.0}                        =  {?}       undefined                           undefined  -- case []       foldl f undefined []                undefined [] --   =  {foldl.1}                        =  {?}       undefined                           undefined  -- case (x:xs)       foldl f undefined (x:xs)            undefined (x:xs) --   =  {foldl.2}                        =  {?}       foldl f (f undefined x) xs          undefined --   =  {f is strict}       foldl f (undefined x) xs --   =  {?}       foldl f undefined xs --   =  {induction}       undefined xs --   =  {?}       undefined 

As an aside, my proof for the dual of the above rule for foldr:

-- f x is strict  ⟹  foldr f is strict  (i.e., foldr f undefined = undefined)        foldr f undefined xs       =        undefined xs  -- case undefined       foldr f undefined undefined         undefined undefined --   =  {foldr.0}                        =  {?}       undefined                           undefined  -- case []       foldr f undefined []                undefined [] --   =  {foldr.1}                        =  {?}       undefined                           undefined  -- case (x:xs)      foldr f undefined (x:xs)             undefined (x:xs) --  =  {foldr.2}                         =  {?}      f x (foldr f undefined xs)           undefined --  =  {induction}      f x (undefined xs) --  =  {?}      f x undefined                      --  =  {f x is strict}      undefined 

The given rule:

-- f is strict  ⟹  foldl f e (xs ++ ys)  =  foldl f (foldl f e xs) ys        foldl f e (xs ++ ys)       =        foldl f (foldl f e xs) ys  -- case undefined       foldl f e (undefined ++ ys)         foldl f (foldl f e undefined) ys --   =  {++.0}                           =  {foldl.0}       foldl f e undefined                 foldl f undefined ys --   =  {foldl.0}                        =  {f is strict  ⟹  foldl f is strict}       undefined                           undefined ys --                                       =  {?}                                           undefined  -- case []      foldl f e ([] ++ ys)                 foldl f (foldl f e []) ys --  =  {++.1}                            =  {foldl.1}      foldl f e ys                         foldl f e ys  -- case (x:xs)      foldl f e ((x:xs) ++ ys)             foldl f (foldl f e (x:xs)) ys --  =  {++.2}                            =  {foldl.2}      foldl f e (x : (xs ++ ys))           foldl f (foldl f (f e x) xs) ys --  =  {foldl.2}                         =  {induction}      foldl f (f e x) (xs ++ ys)           foldl f (f e x) (xs ++ ys) 

My solution to the exercise:

-- f is strict  ⟹  foldl f e . concat  =  foldl (foldl f) e        foldl f e (concat xs)       =       foldl (foldl f) e xs  -- case undefined       foldl f e (concat undefined)        foldl (foldl f) e undefined --   =  {concat.0}                       =  {foldl.0}       foldl f e undefined                 undefined --   =  {foldl.0}       undefined  -- case []       foldl f e (concat [])               foldl (foldl f) e [] --   =  {concat.1}                       =  {foldl.1}       foldl f e []                        e --   =  {foldl.1}       e  -- case (x:xs)       foldl f e (concat (x:xs))           foldl (foldl f) e (x:xs) --   =  {concat.2}                       =  {foldl.2}       foldl f e (x ++ concat xs)          foldl (foldl f) (foldl f e x) xs --   =  {f is strict  ⟹  foldl f e (xs ++ ys)  =  foldl f (foldl f e xs) ys}       foldl f (foldl f e x) (concat xs) --   =  {induction}       foldl (foldl f) (foldl f e x) xs 

Does this work? If so, is it often the case that rules restricted to finite lists can be made to work for all lists given additional strictness requirements like this?

There are several lines above with {?} given as my reasoning. They could be replaced by {undefined x = undefined}, but I am just guessing there. If that is true, how could it be justified?

How to roll for avoiding damage when using Black Hack 1e with optional rule “Original armor”?

The Black Hack 1e has an optional rule called "Original Armour". It reads like this:

Original armor

The traditional concept of ascending AC bonuses can still be used with The Black Hack. Attacks are still made by rolling below attributes (such as STR and DEX) however the AC bonus of the target is added to the roll.

For example in ascending AC systems Leather typically adds +2 to a base of 10 (giving you AC12) – with TBH you would roll an attribute test to see if you hit or are able to avoid taking damage, and add +2 to the dice roll. The quick way to read AC from existing resources is just use the last number as a bonus.

But to avoid taking damage in this edition of the The Black Hack one also has to roll under a stat. In which case it makes no sense, in my opinion, to add +2 to the dice roll. Rather, it makes sense to add +2 to the target number. Is my interpretation correct?

For reference, the Black Hack 1e SRD is here. And the optional rules, including the one in question, are here.