On an initiative roll in Cyberpunk Red, can you roll a critical success or a critical failure?

On an initiative roll in Cyberpunk Red, can you roll a critical success or a critical failure?

The Cyberpunk Red Jumpstart Kit rules read, “When you roll a natural roll of 10 on your d10, you’ve scored a Critical Success” (20), but this is in the context of “Resolving Actions with Skills” – which may be a different context from an initiative roll.

For initiative, the rules merely say, “When a combat starts, everyone rolls Initiative: Initiative = REF + 1d10” (24), and they make no mention of the possibility of a critical success or a critical failure.

film – I got my roll from studio and my last frame had a certain black spot in the left upper corner.Any idea what it can be ? The rest of frames were fine


Your privacy


By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.




unity – How can I roll up a plane like paper?

enter image description here

Hello, I want to twist the plane. The plane looks like this when I try to do it the way I linked below.

How can I my plane roll like photos?

How can I roll up a plane with a vertex shader?

you can see DMGregory answer in this link. I create new shader and paste this code. When I put my mat. to plane. It looks like this.
(Sorry for my bad english.)

enter image description here

alt process – Is taking photos with the back side of a film roll a real technique?

Yes, this technique is known as redscale. You can find a decent amount of information by googling using that term, and see example photos on Flickr. As @MichaelC notes in the comments, on 35mm you’d have to figure out a way of extracting the film from the canister, invert it, and put it back.

You can even do this on B&W film, and there will be an effect, since the light will now be passing through the anti-halation layer first.

I don’t want to waste an entire film roll and realise it didn’t work.

It will work, in the sense that you will get some results out of it, but as with any alternative technique, you pretty much have to be prepared to waste rolls of film (more than one) as you experiment. 🙂 Plus, things can go wrong when unloading and reloading the film into the cartridge.

On the other hand, Lomography makes a redscale film that you load in the normal way – perhaps worth a try as a first approximation to see if you like the results.

field of view – Geocoordinate calculation for aerial oblique image using camera and plane yaw, pitch, roll, and position data

I have a requirement to calculate the ground footprint for an aerial camera. The photos are TerraPhotos. TerraPhoto user guide provide camera position and plane orientation in .IML file. Additionally, I have the camera calibration file.

In TerraPhoto guide, the yaw, pitch, and roll of the aircraft are defined as follows:

  • yaw (heading): from North clock-wise direction
  • roll: positive, if left-wing is up.
  • pitch: positive, if the nose of the aircraft is up

The camera calibration details are as follows:

(TerraPhoto calibration)
Version=20050513
Description= Nikon D800E BW 50mm
TimeOffset= 0.0000
Exposure= 0.00000
LeverArm= 0.0000 0.0000 0.0000
AntennaToCameraOffset= 0.0000 0.0000 0.0000
AttitudeCorrections(HRP)= -0.4546 0.7553 -34.7538
PlateSize= 7630.00000000 4912.00000000
ImageSize= 7630 4912
Margin= 0
FiducialRadius= 40
FiducialMarks= 0
Orientation= BOTTOM
PrincipalPoint(XoYoZo)= -77.40000000 112.80000000 -10476.54389508
LensModel=Balanced
LensK0=0.000000E+000
LensK1=0.000000E+000
LensK2=0.000000E+000
LensP1=0.000000E+000
LensP2=0.000000E+000

Here, I see that AttitudeCorrection for the camera is given. Hence, I believe it is the orientation of the aerial camera according to the local frame (i.e. aircraft).

with respect to a given aerial photo, I have the following details, which I obtained from the.IML file (please check page 344 for more info).

Image=SLR2_443_20150326_144759_C_B_3489_DUBLIN_AREA_2KM2_FL_300_2232888
Time=402972.957799
Xyz=316440.819 234424.606 312.938
Hrp=-113.33234 2.03435 -1.87426
  • Image represent the name of the image
  • XYZ (i.e. camera easting, northing, and elevation)
  • aircraft yaw, pitch, roll

With this specific information at hand, I am attempting to calculate the ground coordinates of the Image. I intend to use Horizontal FoV, and vertical FoV.

I’ve been attempting this for some time, but still unable to estimate the geocoordinates properly. I did attempt, pin-hole model as well. I obtain results around the area of interest, but my results do not confirm the actual geolocations.

I intend to use either pinhole model or Horizontal and Vertical field of view (FoV) to calculate my geocoordinates.

A guide in the right direction is appreciated.

Code with respect to FoV calculation is provided.

def createRollMatrix(yaw,pitch,roll):
  '''
     Uses the Eigen formatted rotation matrix
     pulled directly from Eigen base code to python
  '''
  # convert degrees to radians
  yaw = np.radians(yaw)
  pitch = np.radians(pitch)
  roll = np.radians(roll)

  su = np.sin(roll)
  cu = np.cos(roll)
  sv = np.sin(pitch)
  cv = np.cos(pitch)
  sw = np.sin(yaw)
  cw = np.cos(yaw)

  rotation_matrix = np.zeros((3,3))
  
  rotation_matrix(0)(0) = cv*cw
  rotation_matrix(0)(1) = su*sv*cw - cu*sw
  #rotation_matrix(0)(2) = su*sw + cu - cu*sw
  rotation_matrix(0)(2) = su*sw + cu*sv*cw
  
  rotation_matrix(1)(0) = cv*sw
  rotation_matrix(1)(1) = cu*cw + su*sv*sw
  rotation_matrix(1)(2) = cu*sv*sw - su*cw

  rotation_matrix(2)(0) = -sv
  rotation_matrix(2)(1) = su*cv
  rotation_matrix(2)(2) = cu*cv

  return rotation_matrix

#### CAMERA misalignment angles
yaw = -0.4546 #  
pitch = -34.7538  # 
roll = 0.7553 #  0 

#### aircraft's yaw pitch roll
yaw1 =  -113.33234
pitch1 =  -1.87426
roll1 = 2.03435

R = createRollMatrix(yaw,pitch,roll)
R2 = createRollMatrix(yaw1,pitch1,roll1)

Corrected_R = (R2.dot(R))

yaw = math.atan(Corrected_R(1)(0)/ Corrected_R(0)(0))
yaw

roll =  math.atan(Corrected_R(2)(1)/ Corrected_R(2)(2))
roll

pitch = math.atan(-Corrected_R(2)(0)/ math.sqrt( (math.pow(Corrected_R(2)(1), 2) + math.pow(Corrected_R(2)(2), 2))))
pitch

Subsequently, I use the following code to calculate the geocoordinates.

import math
import numpy as np 

# pip install vector3d
from vector3d.vector import Vector


class CameraCalculator:
    """Porting of CameraCalculator.java
    This code is a 1to1 python porting of the java code:
        https://github.com/zelenmi6/thesis/blob/master/src/geometry/CameraCalculator.java
    referred in:
        https://stackoverflow.com/questions/38099915/calculating-coordinates-of-an-oblique-aerial-image
    The only part not ported are that explicetly abandoned or not used at all by the main
    call to getBoundingPolygon method.
    by: milan zelenka
    https://github.com/zelenmi6
    https://stackoverflow.com/users/6528363/milan-zelenka
    example:
        c=CameraCalculator()
        bbox=c.getBoundingPolygon(
            math.radians(62),SLR2_443_20150326_144759_C_B_3489_DUBLIN_AREA_2KM2_FL_300_2233046
            math.radians(84),
            117.1, 
            math.radians(0),
            math.radians(33.6),
            math.radians(39.1))
        for i, p in enumerate(bbox):
            print("point:", i, '-', p.x, p.y, p.z)
    """

    def __init__(self):
        pass

    def __del__(delf):
        pass

    @staticmethod
    def getBoundingPolygon(FOVh, FOVv, altitude, roll, pitch, heading):
        '''Get corners of the polygon captured by the camera on the ground. 
        The calculations are performed in the axes origin (0, 0, altitude)
        and the points are not yet translated to camera's X-Y coordinates.
        Parameters:
            FOVh (float): Horizontal field of view in radians
            FOVv (float): Vertical field of view in radians
            altitude (float): Altitude of the camera in meters
            heading (float): Heading of the camera (z axis) in radians
            roll (float): Roll of the camera (x axis) in radians
            pitch (float): Pitch of the camera (y axis) in radians
        Returns:
            vector3d.vector.Vector: Array with 4 points defining a polygon
        '''
        # import ipdb; ipdb.set_trace()
        ray11 = CameraCalculator.ray1(FOVh, FOVv)
        ray22 = CameraCalculator.ray2(FOVh, FOVv)
        ray33 = CameraCalculator.ray3(FOVh, FOVv)
        ray44 = CameraCalculator.ray4(FOVh, FOVv)

        rotatedVectors = CameraCalculator.rotateRays(
                ray11, ray22, ray33, ray44, roll, pitch, heading)
        
        #origin = Vector(0, 0, altitude) # 
        #origin = Vector(0, 0, altitude) # 

   
   ###   FW ---- SLR1
    

        #  origin = Vector(316645.779, 234643.179, altitude)

        '''
        BW ===== SLR2 
        '''
        origin = Vector(316440.819, 234424.606, altitude)
        #origin = Vector(316316, 234314, altitude)
        intersections = CameraCalculator.getRayGroundIntersections(rotatedVectors, origin)

        return intersections


    # Ray-vectors defining the the camera's field of view. FOVh and FOVv are interchangeable
    # depending on the camera's orientation
    @staticmethod
    def ray1(FOVh, FOVv):
        '''
        tasto
        Parameters:
            FOVh (float): Horizontal field of view in radians
            FOVv (float): Vertical field of view in radians
        Returns:
            vector3d.vector.Vector: normalised vector
        '''
        pass
        ray = Vector(math.tan(FOVv / 2), math.tan(FOVh/2), -1)
        return ray.normalize()

    @staticmethod
    def ray2(FOVh, FOVv):
        '''
        Parameters:
            FOVh (float): Horizontal field of view in radians
            FOVv (float): Vertical field of view in radians
        Returns:
            vector3d.vector.Vector: normalised vector
        '''
        ray = Vector(math.tan(FOVv/2), -math.tan(FOVh/2), -1)
        return ray.normalize()

    @staticmethod
    def ray3(FOVh, FOVv):
        '''
        Parameters:
            FOVh (float): Horizontal field of view in radians
            FOVv (float): Vertical field of view in radians
        Returns:
            vector3d.vector.Vector: normalised vector
        '''
        ray = Vector(-math.tan(FOVv/2), -math.tan(FOVh/2), -1)
        return ray.normalize()

    @staticmethod
    def ray4(FOVh, FOVv):
        '''
        Parameters:
            FOVh (float): Horizontal field of view in radians
            FOVv (float): Vertical field of view in radians
        Returns:
            vector3d.vector.Vector: normalised vector
        '''
        ray = Vector(-math.tan(FOVv/2), math.tan(FOVh/2), -1)
        return ray.normalize()

    @staticmethod
    def rotateRays(ray1, ray2, ray3, ray4, roll, pitch, yaw):
        """Rotates the four ray-vectors around all 3 axes
        Parameters:
            ray1 (vector3d.vector.Vector): First ray-vector
            ray2 (vector3d.vector.Vector): Second ray-vector
            ray3 (vector3d.vector.Vector): Third ray-vector
            ray4 (vector3d.vector.Vector): Fourth ray-vector
            roll float: Roll rotation
            pitch float: Pitch rotation
            yaw float: Yaw rotation
        Returns:
            Returns new rotated ray-vectors
        """
        sinAlpha = math.sin(yaw) #sw OK
        sinBeta = math.sin(pitch) #sv OK
        sinGamma = math.sin(roll) #su OK
        cosAlpha = math.cos(yaw) #cw OK
        cosBeta = math.cos(pitch) #cv OK
        cosGamma = math.cos(roll) #cu OK
        m00 = cosBeta * cosAlpha # cosAlpha * cosBeta  #cw*cv 
        m01 = sinGamma * sinBeta * cosAlpha - cosGamma * sinAlpha # cosAlpha * sinBeta * sinGamma - sinAlpha * cosGamma     #cw*sv#cu
        m02 = sinGamma * sinAlpha +  cosGamma * cosAlpha * sinBeta#cosAlpha * sinBeta * cosGamma + sinAlpha * sinGamma
        m10 = sinAlpha * cosBeta
        m11 = sinAlpha * sinBeta * sinGamma + cosAlpha * cosGamma
        m12 = sinAlpha * sinBeta * cosGamma - cosAlpha * sinGamma
        m20 = -sinBeta
        m21 = cosBeta * sinGamma
        m22 = cosBeta * cosGamma
        
        # Matrix rotationMatrix = new Matrix(new double()(){{m00, m01, m02}, {m10, m11, m12}, {m20, m21, m22}})
        rotationMatrix = np.array(((m00, m01, m02), (m10, m11, m12), (m20, m21, m22)))

        # Matrix ray1Matrix = new Matrix(new double()(){{ray1.x}, {ray1.y}, {ray1.z}})
        # Matrix ray2Matrix = new Matrix(new double()(){{ray2.x}, {ray2.y}, {ray2.z}})
        # Matrix ray3Matrix = new Matrix(new double()(){{ray3.x}, {ray3.y}, {ray3.z}})
        # Matrix ray4Matrix = new Matrix(new double()(){{ray4.x}, {ray4.y}, {ray4.z}})
        ray1Matrix = np.array(((ray1.x), (ray1.y), (ray1.z)))
        ray2Matrix = np.array(((ray2.x), (ray2.y), (ray2.z)))
        ray3Matrix = np.array(((ray3.x), (ray3.y), (ray3.z)))
        ray4Matrix = np.array(((ray4.x), (ray4.y), (ray4.z)))
        
        res1 = rotationMatrix.dot(ray1Matrix)
        res2 = rotationMatrix.dot(ray2Matrix)
        res3 = rotationMatrix.dot(ray3Matrix)
        res4 = rotationMatrix.dot(ray4Matrix)
        
        rotatedRay1 = Vector(res1(0, 0), res1(1, 0), res1(2, 0))
        rotatedRay2 = Vector(res2(0, 0), res2(1, 0), res2(2, 0))
        rotatedRay3 = Vector(res3(0, 0), res3(1, 0), res3(2, 0))
        rotatedRay4 = Vector(res4(0, 0), res4(1, 0), res4(2, 0))
        rayArray = (rotatedRay1, rotatedRay2, rotatedRay3, rotatedRay4)
        
        return rayArray

    @staticmethod
    def getRayGroundIntersections(rays, origin):
        """
        Finds the intersections of the camera's ray-vectors 
        and the ground approximated by a horizontal plane
        Parameters:
            rays (vector3d.vector.Vector()): Array of 4 ray-vectors
            origin (vector3d.vector.Vector): Position of the camera. The computation were developed 
                                            assuming the camera was at the axes origin (0, 0, altitude) and the python
                                            results translated by the camera's real position afterwards.
        Returns:
            vector3d.vector.Vector
        """
        # Vector3d () intersections = new Vector3d(rays.length);
        # for (int i = 0; i < rays.length; i ++) {
        #     intersections(i) = CameraCalculator.findRayGroundIntersection(rays(i), origin);
        # }
        # return intersections

        # 1to1 translation without python syntax optimisation
        intersections = ()
        for i in range(len(rays)):
            intersections.append( CameraCalculator.findRayGroundIntersection(rays(i), origin) )
        return intersections

    @staticmethod
    def findRayGroundIntersection(ray, origin):
        """
        Finds a ray-vector's intersection with the ground approximated by a planeç
        Parameters:
            ray (vector3d.vector.Vector): Ray-vector
            origin (vector3d.vector.Vector): Camera's position
        Returns:
            vector3d.vector.Vector
        """
        # Parametric form of an equation
        # P = origin + vector * t
        x = Vector(origin.x,ray.x)
        y = Vector(origin.y,ray.y)
        z = Vector(origin.z,ray.z)
        
        # Equation of the horizontal plane (ground)
        # -z = 0
        
        # Calculate t by substituting z
        t = - (z.x / z.y)
        
        # Substitute t in the original parametric equations to get points of intersection
        return Vector(x.x + x.y * t, y.x + y.y * t, z.x + z.y * t)

dnd 5e – Does a monster with multiple abilities recharging regain their use on a roll of 5-6?

From the MM, pg. 11

Recharge X-Y. The notation “Recharge X- Y” means
a monster can use a special ability once and that the
ability then has a random chance of recharging during
each subsequent round of combat. At the start of each
of the monster’s turns, roll a d6. If the roll is one of the
numbers in the recharge notation, the monster regains
the use of the special ability. The ability also recharges
when the monster finishes a short or long rest.

I couldn’t find any creatures with multiple abilities which recharge, but I was working on creating a BBEG which has 3 different abilities that recharge. The question is, rather simply, should I roll a single d6 at the start of each of its turns, or should I roll (up to) 3d6, one for each “discharged” ability?

dnd 5e – Does a natural 20 on the attack roll still automatically hit if the target is wearing adamantine armor?

As much as I am loathe to say it, this is a DM discretion call. First, some questions because the answers form the basis for how to handle anything other than a natural 20 against normal armor.

What is a “critical hit”? What is an “automatic hit”?

There are three relevant places critical hits come up: the general combat rules regarding natural 20s, the specific rules for adamantine armor, and the specific rules for champion fighter. Taken individually or in pairs, these three references to critical hits may seem clear. Considering all three together creates a situation where the ruling on one pair affects the ruling on the other.

Here’s the can of worms…

The Basic Rules have the following passage:

Rolling 1 or 20. (…)If the d20 roll for an attack is a 20, the attack hits regardless of any modifiers or the target’s AC. This is called a critical hit, which is explained later in this section.

Later on in the Damage Rolls section, it describes the damage effects of a critical hit. It all seems clear at this point – a natural 20 being automatic hit and a critical hit are the same thing.

However, when we look at the champion fighter’s Improved Critical ability, we have:

Improved Critical. Beginning when you choose this archetype at 3rd level, your weapon attacks score a critical hit on a roll of 19 or 20.

“Rolling 1 or 20” indicates that a die roll of 20 automatically hits, and calls it a critical hit. Champion fighter also calls a 19 or 20 a critical hit. Does that mean a 19 is also an automatic hit just like a 20?

Adamantine Armor says:

While you’re wearing it, any critical hit against you becomes a normal hit.

What’s a “normal hit”, then? Remember that Armor Class is not about being hit, it…

…represents how well your character avoids being wounded in battle.

A “normal hit” uses the comparison between attack roll and AC to determine if the character is wounded. When an attack roll doesn’t match the target’s AC, it doesn’t mean the attack misssed, it just means it didn’t hit well enough to do damage.

There are two choices, both logically sound, each internally consistent, but also mutually exclusive.

  1. If the DM wishes to consider an “automatic hit” and the dice-doubling “critical hit” to be separate things.
    • On a 20, adamantine stops the damage (“critical hit”), but the “automatic hit” carries through because a 20 always hits.
    • Champion fighters automatically hit on 20s, but not 19s (a 19 is a “critical hit” but not an “automatic hit”.).
  2. If the DM wishes to consider “automatic hit” and the dice-doubling “critical hit” as synonymous:
    • Adamantine stops the dice-doubling from the “critical hit” and, because they’re the same thing, also stops the “automatic hit” (compare the total attack roll to the AC as with a “normal hit”).
    • Champion fighters count 19s (and eventually 18s) as “critical hits”, which means they are also “automatic hits”.

To put it differently… any two of them (the combat rules, adamantine armor, and the champion fighter), isolated from the third, doesn’t leave much room for doubt. It is the interaction of all three passages that creates ambiguity.

I’ve specifically avoided sharing my opinion, and presented two possible interpretations. The published rules don’t provide sufficient clarity or weight to make an iron-clad determination either way.

On Twitter, “official” rulings, and designer intent:

While there are some designer-intent posts on Twitter, they have not made it into an officially published errata. Considering the number of times those seemingly official posts have made a call then reverted it, they should all be considered suspect. In fact, in the time since this answer was originally written, WotC has issued a new edition of the Sage Advice Compendium indicating that live tweets are not official clarifications until they appear in a published SAC.

dnd 5e – Does a stunned creature roll Initiative with disadvantage?

Part of our group got stunned before Initiative was rolled:

Stunned

  • A stunned creature is incapacitated (see the condition), can’t move, and can speak only falteringly.
  • The creature automatically fails Strength and Dexterity saving throws.
  • Attack rolls against the creature have advantage.

Incapacitated

  • An incapacitated creature can’t take actions or reactions.

Even though neither condition states that checks are made with disadvantage, our DM ruled to roll Initiative with a disadvantage since they can’t move or take actions. This made sense to all of us, but we are wondering what the ruling by RAW is.

dnd 5e – If a player tries to persuade somebody, what should that creature roll not to be persuaded?

Insight is a perfectly fine skill to use in this situation…if you feel the situation warrants an opposed roll

Not all social interactions require ability checks, nor do they all require opposed rolls.

The DMG has a good section on how to run social interactions without requiring opposed rolls which is worth a read. It also includes this advice (emphasis mine):

Some DMs prefer to run a social interaction as a free-form roleplaying exercise, where dice rarely come into play. Other DMs prefer to resolve the outcome of an interaction by having characters make Charisma checks. Either approach works, and most games fall somewhere in between, balancing player skill (roleplaying and persuading) with character skill (reflected by ability checks).

If you feel and opposed roll is warranted in the situation, then Insight is a fine choice.

The PHB defines Insight as

Your Wisdom (Insight) check decides whether you can determine the true intentions of a creature, such as when searching out a lie or predicting someone’s next move. Doing so involves gleaning clues from body language, speech habits, and changes in mannerisms.

If someone is trying to persuade a PC or an NPC to act a particular way, being able to discern the true intentions of the creature should certainly inform how persuadable the person doing the persuading is.

Alternatively a general Intelligence check,

An Intelligence check comes into play when you need to draw on logic, education, memory, or deductive reasoning.

or a general Charisma check (emphasis mine):

A Charisma check might arise when you try to influence or entertain others, when you try to make an impression or tell a convincing lie, or when you are navigating a tricky social situation.

might also be appropriate to call for given the situation.

pathfinder 1e – If a swashbuckler rolls a nat. 20 on Opportune Parry and Riposte, do they automatically parry attacks even if they do not beat the attack roll?

No

Opportune Parry and Riposte is not an attempt to ‘hit’ anything. They include that it is an

attack roll as if she were making an attack of opportunity

but then goes on to state

If her result is greater than the attacking creature’s result, the creature’s attack automatically misses.

It is an attack like an attack of opportunity for the purpose of abilities (feats, spells, etc) that affect those things but your only goal is to roll greater than the target (the rare exception to ‘meets beats’), not hit anything. Your GM may wish to allow an automatic success, but there is nothing in the rules that specifies that it works.