dnd 3.5e – Can the evocation of shadows (upper) duplicate a contingency spell as well as the companion spell?

This is a longstanding argument in the 3.5e D&D forums. We are not going to settle this argument here.

Your case, however, is not a problem. When evocation of the shadow Acts like contingency, he acts like contingency, which includes the caster with the ability to cast another spell like contingencyFate of companion. If you wanted to, it could even be another cast of (more) evocation of the shadow.

The real problem, as HeyICanChan suggests in a comment, is whether or not a caster can believe their own illusion. You can choose to fail a save throw, but does the caster even have the chance, then?

And there is simply no answer to that. RAW, the lack of a special exception for the caster's own illusions means they are capable of falling for them, but judging the illusions has a lot of room for the DM's decision, so in in practice, it is not at all unreasonable to say that it is simply impossible. Certainly, being able to use greater evocation of shadows launch contingency when you have prohibited Evocation is a heavy nail in the coffin of this school, which is a good reason to refuse the combination, but it is not in the rules (which assume that Evocation is a school too good than the others, even if it is not).

Anyway, really, contingency should be prohibited anyway. Fate is almost certainly the strongest of the game. Its existence completely changes the nature of the game, and not in a good way.

dnd 3.5e – Can the evocation of shadows (upper) duplicate a contingency spell?

I guess Contention is not eligible because Contingency must have a companion spell and an example would be Contigence (Haste) which is not an existing spell.

(Maybe I should have included an evocation spell in the contingency instead, but Celerity was the first spell that came to my mind)

Related question: Can Wish give me a contingent spell?

dnd 5e – How does contingency with healing wounds work with incoming damage?

If a bard selects contingency as a choice of magic secrets, and initiate a level 5 healing with the trigger "when I fall to 1 life", how does incoming damage work?

Let's say he's at 5 hit points. Then it is hit with 30 damage. Does the 25 extra damage remove triggered 5th level healing wounds?

dnd 5th – Question of contingency spell with healing of wounds

If a bard selects contingency as a choice of magic secrets and initiates 5th level processing with the trigger, "when I drop to 1 hit point", how does incoming damage work?

Let's say it's at 5hp. Then it is hit with 30 damage. Does the 25 extra damage remove triggered 5th level healing wounds?

How do problem-solving agents solve contingency problems different from those that solve exploratory problems?

I asked this question to one of my elders and I do not even understand how to approach that. I can not even find help on the internet about it. This will be very helpful if someone gives me an overview of this case

dnd 3.5e – How does the contingency spell interact with pets in D & D3.5?

As usual when it is a question of contingencyambiguities abound.

The only thing that is certain is that you can share contingency with a pet. Nothing in contingency prevents you from doing so and otherwise meets the criteria described by the sharing spells. Since it's a single cast that "affects" two targets, all you need is a single focus statuette.

This brings us to the first problem: the statuette must be "of you". Is it "you" the pitcher or "you" the subject? Or do both have to be simultaneously?

If "you" is supposed to be the thrower, no problem: you and the familiar can benefit from the same statuette that describes you.

If "you" should be the subject, it is unclear whether a statuette describing both your person and your pet will count as a statuette "of you" and "your pet" simultaneously, and so will be valid for both of you , or if it would count as a statuette "of you and your pet" and therefore would not work for any of you. I suppose most people would accept that, but as we are concerned with strict RAW, we have to note this ambiguity: RAW does not allow to determine the "correct" interpretation, because the English language used is ambiguous and no between them is given. stricter definitions in the rules of the game.

If "you" must be both the caster and the subject of the spell (plausible given the usual function of the spell), we have the same question as before, but if the answer is "no", the familiar can not get a contingency at all, even if you were willing to deprive you of it.

Then we come to the much bigger problem: you have to take the statuette away so you can contingency To work. We have another ambiguity here: is it possible for you and your pet to do it at the same time? For example, if your pet is wearing the statuette and you wear yours, do you also plan to wear the statuette for this purpose? Nobody knows! But since there is only one statuette, you need an answer.

Another ambiguity: if you are separated from the statuette, then recover it, the contingency CV? This one is less ambiguous: phrasing "must pay attention to the contingency "strongly suggests that not wearing the focus does not dissipate the contingencyit just makes him inactive. Yet we can not be certain. Anyway, it means that even if you do not wear your usual goal, you can trade the statuette to control which of you is the subject of the contingency at the time.

So, basically, this comes down to four unanswered questions RAW unambiguously:

  1. A statuette "of you" that, in the initial context of the spell, must represent the caster of the spell, its subject or an individual who is simultaneously simultaneously?

    • If "caster", there are fewer problems and we can skip question 2.

    • If "subject", we must be concerned about question 2.

    • If both "the caster" and the "subject", we must be concerned about question 2., and if the answer is "no", then your pet will never be able to profit from it, even if you give up your own contingency.

  2. (Moot if 1. is a "caster") Does a statuette of you and your pet count as both a "statuette of you" and a "statuette of your pet"? contingency?

    • If "no", you will never be able to have a contingency on one of you, and which one is fixed at the moment of casting. If the answer to 1. was "the caster and the subject", then only you will benefit.

    • If "yes", it will depend on the answers given in points 3. and 4.

  3. (Moot if 1. is a "thrower" or if 1. is not a "thrower" and 2. is "no") Does your pet wear while your pet is wearing the statuette account as wearing you? – even the statuette for the pleasure of contingency?

    • If "no", you will never be able to have a contingency on any of you, but if 4. is "yes", you can swap which of you two.

    • If "yes", you can benefit simultaneously.

  4. (Not applicable if 1. is "subject" or "thrower and subject" and 2. is "no" or if 1. is "thrower" 3. is "yes" or if 1. is "subject" or "thrower and subject "and 2. and 3. are both" yes ") If you are separated from the statuette, then retrieve it, the contingency resume its effect?

    • If "no", you will never be able to have a contingency on one of you, and which one is fixed at the moment of casting.

    • If "yes", you can exchange which of you benefits from the contingency at any time by exchanging the statuette between them.

The 1st and 3rd are "probably" true, but the 2nd is actually only a draw; it could go both ways. Engages in semantic arguments about "porting" and philosophical arguments about what it means to own an object, and so on.


Note that I have considered an alternative approach, in which you use two separate castings in order to use two separate statuettes. however, contingency says "You can only use one contingency to spell at once, "not that you can only to have a contingency at a time. Thus, the second broadcast will dissipate the first, even if the first one has been shared with another target and is not active on you. This, at least, is unambiguous.

dnd 5th – Simulacrum transfer a contingency?

According to my interpretation of game design, this probably should not be. But even if that was the case, as I read both spells, the effect of the eventuality would end immediately. The reasoning is the following.

The contingency spell requires a specific component, which is (A statuette of yourself carved from ivory and decorated with gems worth at least 1,500 gp). In addition, the spell has a special end condition related to this material:

In addition, the contingency ends on you if its material component is ever on you.

Assuming that the eventuality is related to the simulacrum (not to the original person), it would require another statuette in possession of the simulacrum. However, Simulacrum states:

It appears to be the same as the original, but it has half of the creature's maximum health and is formed without any equipment.

Although the equipment does not refer to all the equipment, it should be fair to assume that the simulacrum does not create a copy of the 1500 GP statuette (otherwise, you could use it to duplicate elements not related to the equipment, which would be tedious). Therefore, as the simulacrum does not have the required statuette, the contingency spell ends.

3.5nd dnd – Can a caster help another to form a craft contingency spell?

In the craft quota is written

Craft Quota Spell Type: Object Creation
Sources: Complete Arcane
Inapplicable East

You know how to attach semi-permanent spells to a creature and set them
activate under certain conditions. Prerequisites: launcher level
11th. Advantage: You can create any sort that you know.
The development of a quota takes one day for every 1,000 inches.
base price (spell level x roll level x 100 in). To make a
quota, you have to spend 1/25 of this base price in XP and use
raw materials costing half of the basic price. Some spells incur
additional costs in hardware components or XP (as indicated in their
descriptions), which must be paid when the quota period is
created.

In the DM manual, on page 215, is written

Prerequisites: Certain conditions must be met for
character to create a magic object. These include feats, spells and
various requirements such as level alignment, race or gender.
The prerequisites for the creation of an article are given immediately
following the launcher level. A prerequisite can be
provided by a character who prepared the spell (or who knows the spell
spell in the case of a wizard or a bard), or by the use of a
spell completion or spell trigger magic element or spell-like ability
which produces the desired spell effect. For each day that passes
During the creation process, the creator must use a spell to complete his spell.
element (such as a parchment) or a charge of a spell trigger, item (such as
magic wand), if one of these objects is used to provide a
prerequisite. It is possible that several characters cooperate
when creating an element, each participant providing one or
more preconditions. In some cases, cooperation may even be
necessary, for example if a character knows some of the necessary spells
to create an object and another character, know the rest. If two or
more characters cooperate to create an object, they have to agree
themselves who will be considered the creator for the purposes of
determinations where the level of the creator must be known. (His
Generally reasonable, although not mandatory, for the highest level
character involved to bet considered the creator.) The character
designated as the creator, pays the XP required to make the object.
Typically, a list of prerequisites includes an exploit and one or more
spells (or another requirement in addition to the exploit). When two
the spells at the end of the list are separated by "or", one of these spells
is necessary in addition to all the other spells mentioned before the
last two. For example, the prerequisites for a three wish ring
are "Ring Forge, wish or miracle", which means wish or miracle
is necessary as well as the exploit of Forge Ring

  1. Can two characters collaborate to create a contingent spell with this feat?

  2. Can the contingent spell depend on the will of the character casting the spell?

More specifically, I have a clerk and I want to buy a contingency with Antimagic Field. The condition is this: if an enemy launches the disjunction of the mage, the contingency is activated. However, I also wish to be able to interrupt the antimagic field.
I thought that if my clerk cast the spell, he could also interrupt it later since he was the main caster.

5th dnd – Can you convert a spell above the 5th level into the contingency spell?

The PHB says:

Cast a spell at a higher level

When a caster casts a spell using a higher slot
level as the spell, the spell takes the next level for that
molding. For example, if Umara launches a magic missile using one of her
2nd level slots, this magic missile is the 2nd level. Indeed, the
the spell grows to fill the slot in which it is placed. (PHB 201)

According to the rules, an upcast spell counts as whatever level is used to cast it. There is no difference between the level of the slot and the casting level of a spell.

So, minute meteor of melf toss to the 9th level is a 9th level spell and can not be used with contingency because contingency requires the spell, as cast, to be level 5 or lower.

Object Oriented – A Polymorphic Data Socket Factory with Python Contingency Protocols

I am working on a small data team where I developed this tool when we started to encounter several failures on our existing Big Data systems. We have several large data pools, each with its own API, and so far there was no possibility for query-centric problems. In addition, our database sockets did not have a central repository to access our data. This tool aggregates all query platforms into a (relatively) transparent experience by formulating a sockets library and provides redundancy protocols when queries fail. This software is compatible with all SQL-like interfaces with an established Pythonic API, such as Impala, Hive, AWS and Terminal / Command Line Returns.

The use is very simple:

# When instantiating:
#> mquery () imports all sockets and aliases via the factory
#> Default attempts on any socket are 8
#> The default socket is the first socket in the library
#> The default priority is all sockets of the same type as the default socket
#> Default for fail_on_empty and fail_on_zero are both False

# Functional
a = mquery_lite (). query ("SELECT & # 39; test;")
print (str (a))

# Functional with substitutions
a = mquery_lite (). query ("SELECT & # 39; test;", query_attempts = 2, fail_on_zero = True)
print (str (a))

# Object oriented with exemptions
a = mquery_lite (socket_precedence =["pd"]) # Alias ​​matched with the taking of pandas
a.query_attempts = 4
a.query ("SELECT & # 39; test;", query_attempts = 2, fail_on_zero = True)
print (str (a))

# Object oriented with derogations and a handshake
a = mquery_lite (socket_precedence =["all","data"], query_attempts = 4) # The precedence list will be the list of all sockets plus the additional list of all data sockets; there will be duplicates in the precedence list (not problematic)
a.handshake () # Test each socket in the current priority list; only retain those who pass. Duplicates will persist
a.query ("SELECT & # 39; test;")
print (str (a))

Naturally, all proprietary information has been redacted. I've also stripped most bells and whistles to demonstrate the basic functionality and proof of concept in the code below; all the elements of this code are easily accessible on the Internet, but I did not see them related in this way.

The object mquery_lite () is the main process of this code and can be used functionally or instantiated as an object. When called, mquery_lite () determines if a request has been provided. If this is the case, it will occur itself, execute the query, and return the result pointer of the successful socket. If a request is not passed, mquery_lite () remains instantiated and the user-modified parameters are retained.

The sockets are imported via a factory encapsulated in a generator. Their aliases are mapped into a separate library to facilitate their use when calling sockets. The sockets are separated by type (defined in the socket itself) that I prefer to group by the expected output of the socket (for example, data frame, list of lists, generator, etc.), which guarantees a coherent output. case of failure of the request. Sockets retain the results of the query until a new request is submitted.

The socket and alias libraries are automatically built on an instantiation, according to the order in which they are present in the script. Collisions are rectified on a first-come, first-served basis. The following object variables are created at instantiation:

  • query_attempts (8 by default) is the number of attempts that mquery_lite () will make on one socket before moving on to the next. An exponential timer (2 ^ n) sets the pause between repeated requests on a socket.
  • socket_default (none by default) is the socket that will be substituted in the priority list when an unknown alias is provided. Will default to the first socket of the library if none is detected.
  • socket_precedence (default []) is the order in which the sockets will be tried. By default, all sockets of the same type as the default socket of the library are detected.
  • fail_on_empty (False by default) indicates whether a query should throw an exception if it returns empty (useful for command queries).
  • fail_on_zero (False by default) indicates whether a query should throw an exception if it returns to zero (useful for counting).

The results remain and failures occur at the socket level. The handling of allowed errors (occurring from sockets) occurs in the .query () method.

pandas of import
import pyodbc
import time

def peek (x):
try:
then return (x)
except StopIteration:
return None

### ##############################
### Dynamic polymorphic socket factory ##############################################
### ##############################
PermittedSocketError (Exception) class:
"" "
A socket error that should trigger a retry, but not a program end.
"" "
pass

class making:
DSN = "DSN = Your.DSN.Info.Here;" # Used in pyodbc and pandas sockets
def handshake (self, query = "SELECT & # 39; test & # 39 ;;"):
self.execute (query, fail_on_empty = False, fail_on_zero = False)

# Dynamic socket factory
# https://python-3-patterns-idioms-test.readthedocs.io/en/latest/Factory.html
factory class:
objects = {}
def add_factory (id, factory):
factory.factories.puthttps://codereview.stackexchange.com/q/210377 = factory
add_factory = staticmethod (add_factory)
def create_object (id):
if the id is not in factory.objects: # updated for Python 3
usine.objetshttps://codereview.stackexchange.com/q/210377 = eval (id + ".factory ()")
back to factory.objectshttps://codereview.stackexchange.com/q/210377.create()
create_object = staticmethod (create_object)

### ##############################
### Socket Library #################################################################################### ##############
### ##############################
generic_socket class (socket):
alias_socket = ["alias_1", "alias_2"]
    socket_type = "type"

@property
def result (auto):
# Any type of return processing can go here (as a generator to improve the post-analysis)
return yourself

def execute (self, query, fail_on_empty, fail_on_zero):
# Configured for the query
self .__ data_block = None

try:
# Run the order

# The internal handling of error codes by queries must generate exceptions here - useful for non-Pythonic returns (eg, command line)
# Probably not necessary if you use processes with full Pythonic exception handling
if / * Authorized error behavior * /:
raises PermittedSocketError ("[msg] ")
other:
raise

if fail_on_empty and / * Check if empty * /:
waived PermittedSocketError ("Empty return detected.")
if fail_on_zero and / * Check if zero * /:
waived PermittedSocketError ("Back to Zero Detected.")

# External Processing of Allowed Queries for Allowed Socket Errors - Pythonic Exceptions Must be Captured Here
except PermittedSocketError:
# Post-processing error allowed, such as resetting security protocols or invalidating metadata
# Authorized errors are raised again and processed in mquery_lite ()
raise

factory class:
def create (auto):
return generic_socket ()

pandas_socket (socket) class:
alias_socket = ["pandas","pd"]
    socket_type = "data"

@property
def result (auto):
returns self.data_block

def execute (self, query, fail_on_empty, fail_on_zero):
self.data_block = None
try:
connection = pyodbc.connect (self.DSN, autocommit = True)
self.data_block = pandas.read_sql (request, login)
connection.close ()
if fail_on_empty and self.data_block.dropna (). empty:
waived PermittedSocketError ("Empty return detected.")
if fail_on_zero and self.data_block.shape == (1,1) and int (float (self.data_block.iloc[0,0])) == 0:
waived PermittedSocketError ("Back to Zero Detected.")
except PermittedSocketError:
raise

factory class:
def create (auto):
returns pandas_socket ()


class pyodbc_socket (socket):
alias_socket = ["pyodbc"]
    socket_type = "standard"

@property
def result (auto):
returns self.data_block

def execute (self, query, fail_on_empty, fail_on_zero):
self.data_block = None
try:
connection = pyodbc.connect (self.DSN, autocommit = True)
cursor = connection.cursor ()
cursor.execute (query)
self.data_block = cursor.fetchall ()
cursor.close ()
connection.close ()
row = peek (iter (self.data_block))
if fail_on_empty and not row:
waived PermittedSocketError ("Empty return detected.")
If fail_on_zero and len (line) == 1 and peek (iter (line)) in (0, "0"):
waived PermittedSocketError ("Back to Zero Detected.")
except pyodbc.ProgrammingError:
# Launched when .fetchall () returns nothing
self .__ data_block = [()]
            waived PermittedSocketError ("Empty return detected.")
except PermittedSocketError:
raise

factory class:
def create (auto):
returns pyodbc_socket ()

### ##############################
### mquery_lite () ################################################################################### #################
### ##############################
mquery_lite class (object):
def __new __ (cls, query = None, query_attempts = 8, socket_default = None, socket_precedence =[], fail_on_empty = False, fail_on_zero = False):
# https://howto.lintel.in/python-__new__-magic-method-explained/
if the query is not None:
mquery_instance = super (mquery_lite, cls) .__ new __ (cls)
mquery_instance .__ init __ (query_attempts, socket_default, socket_precedence, fail_on_empty, fail_on_zero)
mquery_instance.query (query)
returns mquery_instance.get_results ()
other:
returns super (mquery_lite, cls) .__ new __ (cls)

### CTOR
def __init __ (self, query_attempts = 8, socket_default = None, socket_precedence =[], fail_on_empty = False, fail_on_zero = False):

### Socket Library
self.socket_library = {socket .__ name __: factory.create_object (socket .__ name__) for socket in socket .__ subclasses __ ()}
self.socket_aliases = ({socket:[socket] for socket in self.socket_library})
self.socket_aliases.update ({alias:[socket] for socket in self.socket_library for aliases in self.socket_library[socket].socket_aliases if not aliased in self.socket_aliases})
self.socket_aliases.update ({socket_type:[socketpoursocketdansselfsocket_librarysiselfsocket_library[socketforsocketinselfsocket_libraryifselfsocket_library[socketpoursocketdansselfsocket_librarysiselfsocket_library[socketforsocketinselfsocket_libraryifselfsocket_library[socket].socket_type == socket_type]for socket_type in {self.socket_library[unique_socket_type].socket_type for unique_socket_type in self.socket_library}})
self.socket_aliases.update ({"all":[socket for socket in self.socket_library]})

self.query_attempts: int = query_attempts
self.socket_default: str = socket_default
If socket_default is None:
self.socket_default = next (iter (self.socket_library))
self.socket_precedence = socket_precedence
if socket_precedence == []:
self.socket_precedence: list = self.socket_aliases[self.socket_library[self.socket_default]. type_socket]self.fail_on_empty: bool = fail_on_empty
self.fail_on_zero: bool = fail_on_empty

def handshake (auto):
precedence_candidates = []
        for aliases in self.socket_precedence:
for socket in self.socket_aliases[alias]:
try:
self.socket_library[socket].hand shake()
precedence_candidates.append (socket)
except PermittedSocketError:
Carry on
if len (precedence_candidates)! = 0:
self.socket_precedence = precedence_candidates

def get_results (auto):
returns self.result_socket.result

### Execution of the request
def query (self, query, query_attempts = None, socket_precedence =[], fail_on_empty = None, fail_on_zero = None):
Number of replacements
If query_attempts is None:
query_attempts = self.query_attempts
if socket_precedence ==[]:
for i in self.socket_precedence:
for j in self.socket_aliases[i]:
if j in self.socket_library:
socket_precedence.append (j)
other:
socket_precedence.append (self.default_socket)
other:
candidate_precedence = socket_previous[:]
            socket_precedence = []
            for i in candidate_previous:
for j in self.socket_aliases[i]:
if j in self.socket_library:
socket_precedence.append (j)
other:
socket_precedence.append (self.default_socket)
if fail_on_empty is null: fail_on_empty = self.fail_on_empty
If fail_on_zero is None: fail_on_empty = self.fail_on_zero

# Loop in the socket priority list
for socket in socket_precedence:
try:
# Loop by socket attempts on the current socket
for tentative_n in the interval (query_attempts):
try:
# Exponential timer; pause 2 ^ n seconds on the current socket
if attempt_n> 0:
print ("Waiting" + str (2 ** attempt_n) + "seconds before trying again ...")
for k in the range (2 ** attempt_n): time.sleep (1)
# Query attempt
self.socket_library[socket].execute (query, fail_on_empty, fail_on_zero)
self.result_socket = self.socket_library[socket]
                        return

except PermittedSocketError:
print ("mquery () failed on the socket " "+ str (socket) +"  ".")
If attempt_n + 1 == wait_query:
raise
pass

except PermittedSocketError:
if socket == socket_precedence[-1]:
print ("mquery () failed after trying all attempts on all sockets.")
raise
print ("mquery () failed after all attempts on the socket " "+ str (socket) +"  "; switch to the next socket.")
Carry on

The questions are mainly about: We tried to make this as "pythonic" as possible – did we forget something? Are there libraries that are already doing this more efficiently?