dnd 5e – With Blind Fighting style from Tasha’s Cauldron Of Everything, can you cast spells that require a target you can see?

Blind Fighting, as phrased in Tasha’s Cauldron Of Everything, contains additional wording beyond the description of mere Blindsight. The entry for Blind Fighting reads:

You have blindsight with a range of 10 feet. Within that range, you
can effectively see anything that isn’t behind total cover, even if
you’re blinded or in darkness. Moreover, you can see an invisible
creature within that range, unless the creature successfully hides
from you.

Using the optional Class Features for the Fighter class which are presented in TCoE, this Blind Fighting fighting style offers not only 10ft of Blindsight, but the wording above, which by my reading at least heavily implies that you should be able to cast spells which target a space, object, or creature “you can see”, within the 10ft range of this ability.

You can explicitly “see an invisible creature”, but does “you can effectively see anything that isn’t behind total cover” mean that you can cast sighted spells on targets within that 10ft range?

Can I customize SharePoint Modern Teams site global menu style?

Anyone got any easyish ideas for styling this global nav menu in a modern UI SharePoint Team site?
The text is so tiny these days, and the child site model works better for this team as all content is managed by the Learning&Development group.
(Big Global org, so no access to use PnP SPFx, and no chance to change tenancy settings. Need something we can do at a Site collection level really).
Google is not my friend today! Is there anything we can do?
Can this menu be formatted?

coding style – Variable name re-use: can it be a good thing?

Famously, from how to write unmaintainable code, it is said unmaintainable code reuses variable names:

Wherever the rules of the language permit, give classes, constructors, methods, member variables, parameters and local variables the same names. For extra points, reuse local variable names inside {} blocks. The goal is to force the maintenance programmer to carefully examine the scope of every instance. In particular, in Java, make ordinary methods masquerade as constructors.

I understand how this can be abused, but I’ve seen very readable code make good use of this technique. Generally that code has small method bodies, and the name is consistent, in that it always represents the same effective object (although it may be normalized or transformed in each step, or maybe a default value that was overridden). Often there is also only one object that matters in the method (so the code follows single-responsibility principles well).

However, I can’t remember any concrete examples of this from well-regarded open source, although I have seen them. Anyone have some examples that demonstrate how to use this technique well, and how it may be clearer than alternatives? Pull requests that refactor in this direction with notes as to why would be especially good answers.

magento2.3.4 – Global variable override by Bootstrap style

I have declare h1 tag font size in global variable,


@h1__font-size: 48px !important;

Declare inside the custom less file,


h1 {

When i see website home page, the font override by bootstrap font.

How to apply by global variables to home page?

coding style – Are there published guidelines, standards, or references that propose unlimited chars per line?

In general, you want to make your code readable. This means that the amount of characters on one line is up to you, your organization that you work for, or your professor if you are in school.

If you have an ultra wide monitor and you are developing your own code for your own project, then it is completely up to you.

Here is a link that talks about line widths that can be too wide making it difficult for the person reading the code/text to understand: https://baymard.com/blog/line-length-readability

There is no concrete answer to this question. Use your best judgement.

dnd 5e – Which damage dice exactly does the Great Weapon Fighting fighting style allow you to reroll?

I called Wizards of the Coast for an official answer, which I’ll summarize.

How Great Weapon Fighting works is that it lets the player who has the GWF fighting style and is using a melee weapon two-handed can reroll all of the damage associated with that weapon.

For example, some weapons that fall under this category are a greatsword or maul, flame tongue, frost brand, vorpal sword, and the sentient weapon Hazirawn from the Hoard of the Dragon Queen adventure. Even the extra damage coming from those weapons can be rerolled as per the Great Weapon Fighting fighting style.

The spells that also allow for this effect are elemental weapon and holy weapon. Specifically because they turn the weapon into a magical weapon that does additional weapon damage.

However, while all of these weapons and spells allow rerolls, what doesn’t allow rerolls are literally whatever isn’t coming from the weapon. Divine Smite, the half orc’s Brutal Critical trait (boo, I know, but I don’t think anyone really cares about that one), the rogue’s Sneak Attack feature, the hex spell, and the hunter’s mark spell are all features that have been under debate, and all of them don’t allow rerolls by the rules.

However, having said all of that, I stress that while at a table, the DM has the ultimate authority to allow or not allow this or that rule into the game. Hope I helped clarify how the rules worked to a degree.

c – Remapping of arrays on structs (code style)

I’m working on a piece of code that remaps a set of signals (1-D integer arrays) onto a set of multi channel samples. I hope the typedefs and the remapping clearifies what I mean. If not, please let me know.

#include <stdint.h>

#define SIGNAL_LENGTH 1024

* Multiple linear input signals as read by a previous input stage 
typedef struct {
    // Mics inside
    int32_t micInside0(SIGNAL_LENGTH);
    int32_t micInside1(SIGNAL_LENGTH);
    int32_t micInside2(SIGNAL_LENGTH);
    int32_t micInside3(SIGNAL_LENGTH);
    // Mics aux
    int32_t micAux0(SIGNAL_LENGTH);
    int32_t micAux1(SIGNAL_LENGTH);
    int32_t micAux2(SIGNAL_LENGTH);
    int32_t micAux3(SIGNAL_LENGTH);
} InputSignals_t;

* Single input struct to be passed to the following filtering stage 
typedef struct {
    // Mic inside 0
    int32_t micInside0a;
    int32_t micInside0b;
    int32_t micInside0Select;
    // Mic inside 1
    int32_t micInside1a;
    int32_t micInside1b;
    int32_t micInside1Select;
    // Mic inside 2
    int32_t micInside2a;
    int32_t micInside2b;
    int32_t micInside2Select;
    // Mic inside 3
    int32_t micInside3a;
    int32_t micInside3b;
    int32_t micInside3Select;
} FilterSample_t;

* Map the linear input signals to interleved multi-channel filter input signals. 
void mapMicFilters(InputSignals_t *inputSignals, FilterSample_t filterSamples(SIGNAL_LENGTH)) {
    for(int i = 0; i < SIGNAL_LENGTH; i++) {
        FilterSample_t *filterSample = &filterSamples(i);
        // I am rather unhappy with the look of the following 
        // code section where the mapping is done.
        // Mic inside 0
        filterSample->micInside0a = inputSignals->micInside0(i);
        filterSample->micInside0b = 0;
        filterSample->micInside0Select = 1;

        // Mic inside 1
        filterSample->micInside1a = inputSignals->micInside0(i);
        filterSample->micInside1b = 0;
        filterSample->micInside1Select = 1;

        // Mic inside 2
        filterSample->micInside2a = inputSignals->micInside0(i);
        filterSample->micInside2b = 0;
        filterSample->micInside2Select = 1;

        // Mic inside 3
        filterSample->micInside3a = inputSignals->micInside0(i);
        filterSample->micInside3b = 0;
        filterSample->micInside3Select = 1;

I am rather unhappy with the look of the code section where the mapping is done.The reason for this is that the lines become very long when the signal names become more specific (therefore longer). But a line break within the statements would really mess up the readability:

filterSample->micInside0a = 
filterSample->micInside0b = 
filterSample->micInside0Select = 

Do you have any suggestions on how to format the code? In dynamic languages I would just take a hashmap with the variable names and loop through it. But I have (and want) to use C.

Thank you!

photo editing – Darktable : using a style to deactivate an operation when exporting a file

I usually set a watermark on my photos and I would like to be able to deactivate sometimes the watermark when I am exporting files from the light table.

Long ago, with an old version of Darktable, I used to achieve that with a style but it doesn’t work anymore.

I tried to recreate the style, and export it. I formatted it with xmlstarlet just to read it :

<?xml version="1.0" encoding="UTF-8"?>
<darktable_style version="1.0">
    <name>Sans Filigrane</name>

I tried to replace <enabled>1</enabled> by <enabled>0</enabled> in the original file and managed to re-import it but it misbehaved exactly the same.

I searched deeper in the Darktable documentation and found that styles are applied like duplicates instances of the modules on top of the history stack. I suspect that deactivating a module at export time couldn’t be achieved by applying a style.

Maybe somebody would have a solution ?

magento2.3.4 – How to handle Global style sheet for my custom theme?

I have created custom theme then creating _extend.less file under appdesignfrontendMy_vendormythemewebcsssource_extend.less do some customization.

Where i can declare global style sheet (Common Components) like primary color, secondary color, primary button color, h1 tag, <p> tag, for all the repeated design for whole pages.

dnd 5e – Does either ability of the thrown weapon fighting style affect boomerangs?

The Fighting Style does little (if anything) for Boomerangs

The Fighting Style states:

You can draw a weapon that has the thrown property as part of the attack you make with the weapon. In addition, when you hit with a ranged attack using a thrown weapon, you gain a +2 bonus to the damage roll.

The first part applies only to weapons with the thrown property, which the Storm Boomerang (and “regular” Boomerangs) do not have.

The second part applies to attacks “using a thrown weapon”. Unfortunately 5e chose to use standard English, meaning we cannot actually tell whether this meant “a weapon that has been thrown” or “a weapon with the thrown property” which are rather different phrases. After all, you can throw a club (or any other weapon) by making a ranged improvised attack.

5e gives us no way of determining which of these phrases it meant so it will be up the GM to determine which interpretation to use and thus, whether or not Boomerangs and improvised ranged attacks using weapons benefit from the Fighting Style.

Personally, because “thrown” is a game-defined property, I would assume it is intended to mean that property; but 5e does not capitalize, italicize, or otherwise differentiate between something being thrown and something having the thrown property, so that’s just what I would do.

This makes no sense to me

This is why, at my own tables, I would have the Fighting Style work perfectly well with Boomerangs because they should have the thrown property (they have a short and long range and are literally thrown), but the rather unusual item (the Storm Boomerang) does not have this property. I would remedy this at my own tables.