Elemental Damage Subfactor: 100%+Elemental Damage%, 115% for the example above. Both the Skill Subfactor and The Elemental Damage Subfactor stack additivelly within itself, if I added a 20% Fire Damage Bracers then my elemental damage would be 100% +15%+20% = 135%.

• Mar 28, 2017  With Diablo III set to commence with another new season in a couple of days, it is time to highlight some of the best Legendary gems available in the game. Legendary gems go into rings.
• I'm looking for items with increase damage against elites for my Cluster Arrow DH. I've hit +50% fire damage, +50% crit chance and +320%(ish) crit damage which I'm still working on. Right now I'm looking for cost reduction and elite damage, but the only item I know of is the Stone of Jordan and a few non-DH weapons.

An Elite is a monster type in Diablo III.

• Were you looking for information about elite items?

• 1Overview
• 2Elite Types

Overview[edit | edit source]

Elite monsters are any monster which have special attributes not normally found on their base type. Champions, Rares, and also Superunique monsters are all considered 'elite'. The term is a categorical definition which ties into some of the gameplay systems. As an example, some itemmodifiers increase damage to elite monsters by a specific percent. Elite kills are tracked in the player's armory as well as achievements for killing a specific number and type of elites.

Special Attributes[edit | edit source]

Elites have special attributes which are called Boss Modifiers. Note that for Superunique types, these modifiers are not shown, although with champions and rare elites, the special attributes will be visible underneath the monster's nameplate at the top of the screen.

The type and amount of modifiers an elite can have will vary by difficulty and mlvl. An example of this is the knockback modifier, which is present starting around mlvl 4 in normal difficulty. As the player reaches higher difficulties, a larger pool of modifiers will be available to elites, as well as the amount of modifiers an elite can spawn with.

In normal difficulty, an elite can spawn with one boss modifier (although superuniques, covered below, are an exception to that rule). In Nightmare they can spawn with two modifiers, three in Hell, and finally four in Inferno.

Elite Types[edit | edit source]

There are three types of elite monsters in Diablo III.

Superunique[edit | edit source]

Superunique monsters have their name displayed in purple. They vary drastically from the other forms of elites in a few ways.Superunique monsters have fixed spawn locations, but they normally have a low chance to spawn (unless they are quest-related superuniques such as the Skeleton King). They do not come in packs, have set boss modifiers, and also do not count towards a stack of nephalem valor. Set modifers means that superuniques cannot take on a larger number of modifiers in subsequent difficulties. If a superunique spawns with only mortar, as an example, it will spawn in normal or inferno difficulty with only mortar as well. Their modifiers are native and static. For this reason, superuniques tend to be much less deadly than their rare or champion counterparts.All quest monsters, including Diablo, are considered superunique.

Rare[edit | edit source]

Elite rares have their name displayed in yellow. Rares differ from champions and superuniques in that there is one 'boss' monster who has more health and deals more damage than their minions, and there are also certain modifiers which can only spawn on rare-type enemies, such as horde or illusionist.It is often the case that the boss monster in a rare pack has special properties that the minions do not share, due to concerns of game balance in higher difficulty levels. As an example, in a rare pack, only the boss will be able to be harmed with the Invulnerable Minions modifier, and only the boss will be able to use the jailer ability.Rare monsters count towards the nephalem valor buff, but only the boss kill counts. The minions do not refresh or add to a valor stack.

Champion[edit | edit source]

Similar to rare elites, champions have some specific modifiers like Health Link and Fire Chains. A champion's name appears in blue, and in addition their models and textures also have a bright blue glow to them to separate them from the rest of the monsters. Champion packs usually revolve around mechanics such as fire chains which require the monsters to work in tandem, as a team, to attempt to kill the player. There is no 'boss' monster in a champion pack.Champion monsters count towards the nephalem valor buff, but only once all of the champions in a pack have been killed.

Spawn Locations[edit | edit source]

It is worth noting that there are set locations for an elite to spawn, whether it is a rare, champion, or superunique. However, D3 has no internal rules on how many spawn points can actually spawn an elite pack, which lends much more danger to certain areas than others.As an example, shown in the image below, it isn't uncommon to spawn two different elite packs in one small area within the Halls of Agony. The image depicts a rare cultist pack spawn in addition to a champion berserker spawn. Also, the mid-western side of the Desolate Sands zone is particularly deadly, with three or more elite packs spawning at once not being an uncommon sight.

API Reference ▸ Layouts ▸ Stack Layout

The D3 4.0 API Reference has moved. This page describes the D3 3.x API.

The stack layout takes an array of layer objects, each having a series (array) of point objects as a member. The point objects contain a pair of ordinates (as a minimum) that map the horizontal position of each point and its vertical thickness. The output from the stack layout is the same array of layers, but with state added onto the point objects to facilitate the selected stacking strategy.The layout computes a baseline for the first layer which it then propagates to the above layers, so as to produce a stacked data set.Several baseline algorithms are supported, along with sorting heuristics to improve perception, as described in “Stacked Graphs—Geometry & Aesthetics” by Byron & Wattenberg.

The stack layout operates in an arbitrary two-dimensional x and y coordinate space, similar to D3's other layouts, including tree. Thus, layers can be stacked vertically, horizontally, or even radially. While the 'zero' offset is the default, a streamgraph can be generated using the 'wiggle' offset, which attempts to minimize change in slope weighted by layer thickness.

# d3.layout.stack()

Constructs a new stack layout with the default offset (zero) and order (null). The returned layout object is both an object and a function. That is: you can call the layout like any other function, and the layout has additional methods that change its behavior. Like other classes in D3, layouts follow the method chaining pattern where setter methods return the layout itself, allowing multiple setters to be invoked in a concise statement.

#stack(layers[, index])

Computes the y-coordinate baseline for each layer in the layers array, and then propagates that baseline to the other layers. In the simplest case, layers is a two-dimensional array of point objects, all having the same length, and each having a vertical and horizontal ordinate value to define the y-thickness of each layer at the given x-position.

More complex structures are accepted by the layout, but only if an accessor function is passed to values, which abstracts the structure back to the simple case described above. In any case, the complexity is limited to an array of layer objects, each having a points array as a member. It is not possible, for example to use a series hash table (object) containing key value pairs representing the coordinates. Such a structure could be abstracted into the required format using an accessor function but, the object returned by the layout would not have the added offset state, as there is currently no means to abstract the output with layer awareness.

The default layout expects the point objects to carry x and y members, to which it will add a y0 member, to store the offset values produced by the selected baseline algorithm.If the coordinate properties (raw or abstracted) are not named x and y, then x and yaccessors must be provided to complete the abstraction and deliver the above structure.

Thus, each point object has the following abstract structure:

• x - the x-position of the value.
• y - the y-thickness of the value.
• y0 - the minimum y-position of the value (baseline).

The last two being physically added onto the point objects if required.

The optional index argument is not consumed by the default layout, but is made available to custom order and offset objects.

# stack.values([accessor])

Specifies how to extract the points array from the layer elements of the layers array; accessor is a function which is invoked on each input layer passed to stack, equivalent to calling layers.map(accessor) before computing the stack layout. The default values function is the identity function. If accessor is not specified, returns the current values accessor.

The values accessor can be used to associate additional data per-layer, rather than per-point. For example, say your data were structured as follows:

Specify a values accessor that retrieves the points for each layer:

D3 Does Dmg To Elites Stack Free

Then, if you wanted to add a tooltip for each layer, you might say:

# stack.offset([offset])

If offset is specified, sets the stack offset algorithm to the specified value. If offset is not specified, returns the current offset algorithm. The following string values are supported:

• silhouette - center the stream, as in ThemeRiver.
• wiggle - minimize weighted change in slope.
• expand - normalize layers to fill the range [0,1].
• zero - use a zero baseline, i.e., the y-axis.

In addition to a string, offset may be specified as a function. The input to the offset function is the layer data, converted to a standardized representation: a two-dimensional array of values, where each value is represented as a two-element array [x, y]. The return value of the offset function must be an array of values which represents the y-coordinates of the baseline. For example, the default 'zero' offset is implemented as:

# stack.order([order])

If order is specified, sets the stack order to the specified value. If order is not specified, returns the current order. The following string values are supported:

• inside-out - sort by index of maximum value, then use balanced weighting.
• reverse - reverse the input layer order.
• default - use the input layer order.

In addition to a string, order may be specified as a function. The input to the order function is the layer data, converted to the standardized representation: a two-dimensional array of values, where each value is represented as a two-element array [x, y]. The return value of the order function must be an array of indexes which represents the layer order. For example, the default order is implemented as:

See also d3.range.

# stack.x([accessor])

Specifies how to access the x-coordinate of each value’s position. If accessor is specified, sets the accessor to the specified function. If accessor is not specified, returns the current function, which by default assumes that each input value has an x attribute:

The x-accessor is invoked for each input value, for each input layer, being passed the current data (d) and index (i). The return value of the accessor must be a number.

D3 Does Dmg To Elites Stack Mean

The x-coordinate only affects the behavior of the “wiggle” offset; changing this accessor does not affect how data is grouped into stacks. Although the x-accessor is invoked for all layers (not just the bottommost layer), the stack layout assumes that the x-coordinates of all layers are homogenous and consistent. In other words, each layer must contain the same number of values, at the same x-coordinates, in the same order. If your data is irregular, you will need to reinterpolate or reorder the data before computing the stack.

# stack.y([accessor])

Specifies how to access the y-coordinate of each value's thickness. If accessor is specified, sets the accessor to the specified function. If accessor is not specified, returns the current function, which by default assumes that each input value has a y attribute:

The y-accessor is invoked for each input value, for each input layer, being passed the current data (d) and index (i). The return value of the accessor must be a number. With the exception of the 'expand' offset, the stack layout does not perform any automatic scaling of data. To simplify scaling, use this layout in conjunction with a linear scale or similar.

# stack.out([setter])

Specifies how to propagate the computed baseline to above layers. If setter is specified, it is used as the output function. If setter is not specified, returns the current output function, which by default assumes that each input value has y and y0 attributes:

The setter is invoked for each input value, for each input layer, being passed the current data (d), the computed y0 value, and the computed y-thickness. In all cases except the 'expand' offset, the y-thickness is the same as the input value returned by y, and thus may be ignored.