Shared Damage

A mod that links players together — they share damage, healing, and hunger. Take a hit, your party feels it. Built for Minecraft 1.12.2 / Forge, and designed specifically to behave inside heavy modpacks like RLCraft where other "shared health" mods break. Importantly, this is not "everyone shares one HP bar" — each player keeps their own health, armor, and limbs, and the hit is re-delivered to them. (You can switch to a mode where everyone loses the same hearts, if that's what you want.)

Healing, and hunger are individually configurable in the server config if you decide to not want to share those for any reason.

Which version should I use?

There are two builds. For most servers, 3.2.0 is the one to run:

Running a nicer, more individually configurable client-side view? Use 3.2.0 — the full build, and the recommended choice for servers. It costs the server very little extra over the lite build, and it gives every player the option to install the same jar client-side for an on-screen log. Players who don't want it install nothing and fall back to the usual chat / action-bar messages — so you lose nothing by running it.
Want the absolute minimum? Use 2.2.3 — identical sharing and First Aid features, just without the bundled client renderer. The whole mod is only ~50 KB either way, so this is really for purists who'll never use the client option. Functionality is largely unchanged.

All three are server-side and let mod-less clients connect. acceptableRemoteVersions = "*", so the server never rejects anyone, with or without the client mod.

What it does

When players are linked, the following is shared between them:

Damage — when one player is hit, the same hit lands on the others.
Healing — natural regeneration, healing potions/items, and (with First Aid) bandages, plasters, and limb regen are all mirrored to the group.
Hunger — food and saturation changes (both draining and eating) are kept in sync.

Who counts as "linked" is configurable: by default it's everyone on the server, but you can restrict it to scoreboard teams so multiple parties can run on one server without bleeding into each other.

Damage sharing modes

Shared Damage gives you three ways to pass a single-target hit on, controlled by config:

Pre-hit (default). The original attack is re-delivered to each linked player, who tanks it with their own armor. A well-armored teammate takes less than a lightly-armored one. With First Aid, each receiver's own limb is hit and their per-limb armor applies — independently, so it may land on a different limb for each player.
Post-hit (shareFinalDamage = true). Everyone loses the exact final HP the victim lost, ignoring their own armor. With First Aid, this is exact per-limb: the victim's limb losses are replicated onto the same limbs on each teammate, armor-free. This is closer to things like Soul Link where "everyone's HP is the same" (with the caveat that if you have max health differences, it still works).
Mirror hit location (mirrorHitLocation = true, First Aid only). The best of both — when you're hit on, say, your left leg, every linked player takes it on their left leg too, re-mitigated by each player's own armor on that limb. Same location for everyone, but gear still matters and the damage can differ per person.

Area-of-effect damage

Explosions, lightning, and splash/lingering potions hit everyone nearby at once, so naïvely sharing each hit would multiply the blast by the party size. Shared Damage handles AoE specially, controlled by sumAoeDamage:

Sum (true, default). Everyone the AoE hit who is linked has their actual damage taken (post-block, post-armor) summed, and every linked player converges to that total. Two people taking 4 and 5 each end at 9; if everyone fully blocks, nobody takes anything. A block only protects you if the whole group blocks — coordination matters. Lingering clouds apply this per damage tick.
De-dup (false). The blast is shared once — the largest hit taken — only to linked players it missed; players caught in the same blast aren't cross-shared.

First Aid integration

Most shared-health mods read and write a player's health value directly (getHealth() / setHealth()). In packs like RLCraft that ship First Aid — which replaces the vanilla health bar with a per-limb capability system — that approach fights the pack and desyncs.

Shared Damage instead detects First Aid at startup and switches to a limb-aware backend. Shared damage lands on body parts (not raw health), each receiver's per-limb armor is applied by First Aid itself, bandage/plaster healing is shared, and death is handled correctly — items drop and the death message appears, exactly like a normal First Aid death. Notifications also name the limb a shared hit landed on (e.g. "— left arm"). If First Aid isn't present, it cleanly falls back to the vanilla path (and you should be on 1.4.0 anyway).

The on-screen log (3.2.0, optional client mod)

3.2.0 adds an optional client-side display: a small, slow-rolling log in a screen corner. Each shared event (damage, healing, food gained, hunger lost) shows as a line that lingers ~10 seconds then fades out like a subtitle, and pulses in its category colour when a fresh event of that kind arrives — red for damage, green for healing and food, gold for hunger lost. Same-kind events update one line in place rather than stacking, so a sustained fight reads as one pulsing line instead of a wall of text.

It's fully optional. A client with 3.2.0 installed sends a quiet handshake and receives the log; a client without it is untouched and keeps the chat / action-bar messages. The server treats both identically otherwise — you can run 3.2.0 on the server and let some players install the client mod and others not.

Placement and timing live in a client-only config (config/shareddamage-client.cfg): corner, x/y offset, scale, linger, fade, and the colour-pulse settings.

Compatibility

Minecraft: 1.12.2
Mod loader: Forge
Tested with: RLCraft 2.9.3
First Aid: fully supported (2.2.3+) — damage routes to limbs with per-limb armor, healing including bandages is shared, death drops items and posts a message normally, and hits are limb-labelled (3.2.0+).

Installation

Put the jar in the mods/ folder of your server — or, for single-player / LAN worlds (how most people run RLCraft), in your own instance's mods/ folder. Players joining a dedicated server do not need to install it; mod-less clients connect fine.

For 3.2.0, the same jar is also the client mod: any player who wants the on-screen log installs it in their own mods/ folder too. It's optional per player.

Pick the right build: 3.2.0 (recommended — full features, optional client log) or 2.2.3 (lite, no client renderer, less buggy than 1.4.0)

Forming parties

Set useScoreboardTeams = true in the config, then create a team and add players with the vanilla scoreboard commands. Minecraft 1.12.2 uses the older /scoreboard teams syntax (not the /team commands from 1.13+):

/scoreboard teams add friends
/scoreboard teams join friends Steve
/scoreboard teams join friends Alex

Only players on the same team will share with each other. Other handy commands:

/scoreboard teams list              List all teams and their members
/scoreboard teams leave Steve       Remove a player from their team
/scoreboard teams remove friends    Delete the team

Run these from the server console, or in-game with op/cheats enabled.

Configuration

The main config is at config/shareddamage.cfg, editable live from the in-game Mod Options screen.

Damage

Option	Default	Description
`fullDamageToEveryone`	`true`	`true`: everyone takes the full hit. `false`: the hit is split evenly across the group.
`useScoreboardTeams`	`false`	`true`: only same-team players are linked. `false`: all online players are linked.
`sameDimensionOnly`	`false`	Only link players in the same dimension.
`preventSharedDeath`	`false`	Shared damage won't directly kill a linked player (leaves them at 1 HP). The original victim can still die. Not applied in mirror mode.
`sharedDamageMultiplier`	`1.0`	Scales passed-on damage. `0.5` = linked players take half.
`shareFinalDamage`	`false`	`false` (pre-hit): receivers tank the attack with their own armor. `true` (post-hit): receivers lose the exact final HP the victim lost. With First Aid, post-hit replicates exact per-limb losses, armor-free.
`mirrorHitLocation`	`false`	First Aid only. Shared hits land on the same limb for everyone, re-mitigated by each player's own armor.
`sumAoeDamage`	`true`	`true`: AoE (explosion/lightning/potion) damage taken is summed and everyone converges to that total. `false`: de-dup (one blast to those it missed).
`sharedKnockbackScale`	`0.0`	Knockback from a shared hit, as a fraction of a real hit. `0.0` = none.
`damageTypeBlacklist`	(empty)	Damage types to never share, e.g. `fall`, `drown`, `starve`, `lava`, `outOfWorld`.
`ignoreInvulnerabilityFrames`	`true`	Shared hits bypass i-frames so they always land.

Healing & hunger

Option	Default	Description
`shareHealing`	`true`	Share regeneration, healing potions/items, and (with First Aid) bandages and limb regen.
`healingMultiplier`	`1.0`	Scales shared healing.
`shareHunger`	`true`	Share hunger and saturation changes.
`shareHungerDrains`	`true`	Share food/saturation lost from activity.
`shareHungerGains`	`true`	Share food/saturation gained from eating.

Notifications

Each event type has its own channel — off, chat, or actionbar — so the action bar isn't forced to carry everything. When two or more types share the action bar, they collapse to short coloured tokens (-3♥ +2♥ -1h); a single type shows a full sentence. For clients running the 3.2.0 client mod, all of these flow to the on-screen log instead (the channel choice then only decides what's silenced with off).

Option	Default	Description
`notifyMode`	`actionbar`	Channel for shared damage notices.
`notifyModeHealing`	`chat`	Channel for shared healing notices.
`notifyModeHungerGain`	`chat`	Channel for shared food gained notices.
`notifyModeHungerLoss`	`off`	Channel for shared hunger lost notices.
`notifyShowSource`	`false`	Append what caused the original hit (mob/source name).
`notifyShowLimb`	`true`	With First Aid, append which limb the shared hit landed on, e.g. "— left arm".
`notifyCoalesceTicks`	`8`	Merge rapid events into one running total within this window.
`notifyResetTicks`	`40`	Quiet ticks before the running total resets (20 ticks = 1s).
`notifyMaxNames`	`3`	Max names/limbs to list before collapsing to "+N more".
`debugLogging`	`false`	Log every shared event to the server console. For troubleshooting.

Client display (3.2.0 only)

Client-only, in config/shareddamage-client.cfg. These affect only the player who set them and have no effect server-side.

Option	Default	Description
`enabled`	`true`	Master switch for the on-screen log.
`corner`	`TOP_RIGHT`	`TOP_RIGHT`, `TOP_LEFT`, `BOTTOM_RIGHT`, or `BOTTOM_LEFT`.
`xOffset` / `yOffset`	`4` / `4`	Inset from the chosen corner, in GUI pixels.
`scale`	`1.0`	Text scale.
`lingerSeconds`	`10.0`	How long a line stays solid before fading.
`fadeSeconds`	`1.5`	Length of the fade-out.
`flash`	`true`	Pulse a line in its category colour when a fresh event arrives.
`flashSeconds`	`0.4`	Length of the colour pulse.
`flashStrength`	`0.45`	Peak opacity of the pulse (0–1).

Notes & known nuances

Healing and hunger mirror changes, not absolute values — so the cost of sprinting or the benefit of a bandage is communal, without snapping everyone to an identical number. Respawning does not feed or heal the group (the reset is detected and ignored).
Split damage is approximate. When fullDamageToEveryone = false, each player's slice still passes through their own armor, so post-mitigation totals won't be a perfect ledger. In post-hit and mirror modes under First Aid, sharing is applied to everyone rather than split.
Pre-hit keeps the original attacker as the source, so reflect effects (thorns) and kill credit may point at the original attacker even for distant players. Post-hit uses a generic source, so death messages and kill credit aren't attributed to the original attacker. Blacklist a damage type if this causes trouble.
The client log is optional and degrades gracefully. A 3.2.0 server with a mix of mod and mod-less clients works fine; mod-less players simply get the chat / action-bar messages.

Shared Damage, Hunger, & Healing