Apply teams in gameplay: targeting, explosions, pushing, names, deaths
Mobs on the player's team never target the player; a creeper's blast spares its team mates when its team has no friendly fire; mobs push each other only as their collision rules allow; name tags follow the team's name tag visibility, show the team's prefix, suffix and colour and the score of the objective displayed below names; the player's own death message stays out of chat when the team hides death messages. The criteria that follow the player compare health as a float, round armor down and give auto-updated displays the player's team-formatted name. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -456,6 +456,7 @@ fn main() -> horizon_client::Result<()> {
|
||||
yaw: 0.0,
|
||||
hero: false,
|
||||
uuid: [0, 0x1234, 0, 0x5678],
|
||||
allies: Default::default(),
|
||||
}
|
||||
});
|
||||
let mut scratch = LegacyRandom::new(0);
|
||||
|
||||
@@ -655,15 +655,19 @@ impl Game<'_> {
|
||||
let Some(p) = self.player.as_ref() else {
|
||||
return;
|
||||
};
|
||||
let below_world = p.position.y < f64::from(horizon_client::chunk::MIN_Y - 64);
|
||||
let name = self.player_display_text();
|
||||
let message = match cause {
|
||||
Some(key) => Text::translate(&key, &[Text::literal(PLAYER_NAME)]),
|
||||
None if p.position.y < f64::from(horizon_client::chunk::MIN_Y - 64) => {
|
||||
Text::translate("death.attack.outOfWorld", &[Text::literal(PLAYER_NAME)])
|
||||
}
|
||||
Some(key) => Text::translate(&key, &[name]),
|
||||
None if below_world => Text::translate("death.attack.outOfWorld", &[name]),
|
||||
None => self.combat_death_message(),
|
||||
};
|
||||
self.ui.death_text = Some(message.clone());
|
||||
self.system_message(message);
|
||||
// ServerPlayer.die: a team that hides death messages keeps it out of
|
||||
// the dying player's own chat (the death screen still shows it).
|
||||
if horizon_client::scoreboard::own_death_message_shown(self.player_team()) {
|
||||
self.system_message(message);
|
||||
}
|
||||
}
|
||||
/// F1 hides the HUD (and hand); the screenshot key still works.
|
||||
pub(super) fn toggle_hide_gui(&mut self) {
|
||||
|
||||
@@ -25,6 +25,9 @@ pub(super) struct CombatTracker {
|
||||
pub(super) last_hurt_mob: Option<(u32, i64)>,
|
||||
/// The mob whose projectile is hitting the player now.
|
||||
pub(super) projectile_owner: Option<u32>,
|
||||
/// The mob exploding now (`ServerExplosion.source`): its team's friendly
|
||||
/// fire decides whom the blast may hurt.
|
||||
pub(super) explosion_source: Option<u32>,
|
||||
/// The player's fall distance before this tick's movement (as of the
|
||||
/// end of the last one).
|
||||
fall_before: f64,
|
||||
|
||||
@@ -166,6 +166,7 @@ impl Game<'_> {
|
||||
yaw: self.yaw,
|
||||
hero: self.potions.effects.get("hero_of_the_village").is_some(),
|
||||
uuid: self.level.player_uuid.unwrap_or_default(),
|
||||
allies: std::sync::Arc::new(self.player_allies()),
|
||||
})
|
||||
}
|
||||
/// Biome facts at a position for finalizeSpawn and variant rules.
|
||||
@@ -458,7 +459,14 @@ impl Game<'_> {
|
||||
}
|
||||
keep
|
||||
});
|
||||
push_apart(&mut mobs);
|
||||
// EntitySelector.pushableBy: the collision rules of the mobs' teams.
|
||||
let teams: Vec<Option<horizon_client::scoreboard::Team>> =
|
||||
if self.score.board.teams.is_empty() {
|
||||
Vec::new()
|
||||
} else {
|
||||
mobs.iter().map(|m| self.mob_team(m.id).cloned()).collect()
|
||||
};
|
||||
push_apart(&mut mobs, &teams);
|
||||
}
|
||||
self.mobs.append(&mut mobs);
|
||||
self.sync_riders();
|
||||
@@ -667,18 +675,21 @@ impl Game<'_> {
|
||||
MobEvent::Shoot(..) => {}
|
||||
MobEvent::Explode(at, radius) => {
|
||||
// The exploding mob causes the damage (Creeper.explodeCreeper).
|
||||
if let Some(id) = self
|
||||
let source_mob = self
|
||||
.mobs
|
||||
.iter()
|
||||
.filter(|m| {
|
||||
(m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2) < 1.0
|
||||
})
|
||||
.map(|m| m.id)
|
||||
.next()
|
||||
{
|
||||
.next();
|
||||
if let Some(id) = source_mob {
|
||||
self.note_attacker("minecraft:explosion", id);
|
||||
}
|
||||
self.explode(at, radius)?
|
||||
self.combat.explosion_source = source_mob;
|
||||
let result = self.explode(at, radius);
|
||||
self.combat.explosion_source = None;
|
||||
result?
|
||||
}
|
||||
MobEvent::AttackMob {
|
||||
target,
|
||||
@@ -2421,8 +2432,12 @@ fn from_loot(stack: &horizon_world::loot::LootStack) -> ItemStack {
|
||||
}
|
||||
item
|
||||
}
|
||||
/// Entity.push between overlapping mobs (LivingEntity.pushEntities).
|
||||
fn push_apart(mobs: &mut [Mob]) {
|
||||
/// Entity.push between overlapping mobs (LivingEntity.pushEntities), unless
|
||||
/// their teams' collision rules keep both from pushing the other (`teams`
|
||||
/// holds each mob's team, or is empty when there are no teams).
|
||||
fn push_apart(mobs: &mut [Mob], teams: &[Option<horizon_client::scoreboard::Team>]) {
|
||||
use horizon_client::scoreboard::pushable_by;
|
||||
let team = |i: usize| teams.get(i).and_then(Option::as_ref);
|
||||
let n = mobs.len();
|
||||
for i in 0..n {
|
||||
if !mobs[i].alive() {
|
||||
@@ -2437,6 +2452,12 @@ fn push_apart(mobs: &mut [Mob]) {
|
||||
if mobs[i].extra.mount == Some(mobs[j].id) || mobs[j].extra.mount == Some(mobs[i].id) {
|
||||
continue;
|
||||
}
|
||||
if !teams.is_empty()
|
||||
&& !pushable_by(team(i), team(j), true)
|
||||
&& !pushable_by(team(j), team(i), true)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let (dx, dz) = (
|
||||
mobs[j].position.x - mobs[i].position.x,
|
||||
mobs[j].position.z - mobs[i].position.z,
|
||||
|
||||
@@ -191,6 +191,15 @@ impl Game<'_> {
|
||||
[d[0] / l, d[1] / l, d[2] / l]
|
||||
}
|
||||
};
|
||||
// `source.doTeamsAllowDamage(entity)`: the exploding mob spares its
|
||||
// team mates when its team has no friendly fire (they are still pushed).
|
||||
let exploding = self.combat.explosion_source;
|
||||
let teams_allow = |g: &Self, victim: Option<&horizon_client::scoreboard::Team>| {
|
||||
exploding.is_none_or(|id| {
|
||||
horizon_client::scoreboard::teams_allow_damage(g.mob_team(id), victim)
|
||||
})
|
||||
};
|
||||
let player_hurtable = teams_allow(self, self.player_team());
|
||||
// Player.
|
||||
if let Some(p) = self.player.as_ref() {
|
||||
let feet = [p.position.x, p.position.y, p.position.z];
|
||||
@@ -217,7 +226,7 @@ impl Game<'_> {
|
||||
&& let Some(id) = self.motion.health.damage.id("minecraft:explosion")
|
||||
{
|
||||
// Creative players are invulnerable to explosions.
|
||||
if !creative {
|
||||
if !creative && player_hurtable {
|
||||
hurt = p
|
||||
.hurt(&self.motion.health, self.world.health_rules, id, amount)
|
||||
.unwrap_or(false);
|
||||
@@ -236,6 +245,7 @@ impl Game<'_> {
|
||||
// Mobs.
|
||||
let mut mobs = std::mem::take(&mut self.mobs);
|
||||
for m in mobs.iter_mut().filter(|m| m.alive()) {
|
||||
let hurtable = teams_allow(self, self.mob_team(m.id));
|
||||
let feet = [m.position.x, m.position.y, m.position.z];
|
||||
let dist = distance(feet) / diameter;
|
||||
if dist > 1.0 {
|
||||
@@ -253,7 +263,7 @@ impl Game<'_> {
|
||||
attacker: None,
|
||||
from: Some(center),
|
||||
};
|
||||
if !m.damage(damage(dist, exposure), source) {
|
||||
if hurtable && !m.damage(damage(dist, exposure), source) {
|
||||
continue;
|
||||
}
|
||||
let dir = direction(eye);
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
//! Custom names: `NameTagItem.interactLivingEntity` and the name tag
|
||||
//! (`EntityRenderer.submitNameTag`): above the head, facing the camera,
|
||||
//! on a translucent black background, shown when the name is visible or the
|
||||
//! mob is under the crosshair within 64 blocks.
|
||||
//! mob is under the crosshair within 64 blocks, as its team's name tag
|
||||
//! visibility allows, in the team's colours, with its score in the
|
||||
//! objective displayed below names.
|
||||
use super::{Game, view_vector};
|
||||
use horizon_client::mesher::Vertex;
|
||||
use horizon_client::{mesher::Vertex, save::uuid_text, scoreboard as sb, text::Text};
|
||||
|
||||
impl Game<'_> {
|
||||
/// A named name tag names the mob under the crosshair.
|
||||
@@ -26,17 +28,37 @@ impl Game<'_> {
|
||||
self.swing_arm();
|
||||
true
|
||||
}
|
||||
/// `Entity.belowNameDisplay`: the mob's score in the objective shown below
|
||||
/// names, then a space and the objective's name.
|
||||
fn below_name_text(&self, id: u32) -> Option<Text> {
|
||||
let board = &self.score.board;
|
||||
let objective = board.display_objective(sb::SLOT_BELOW_NAME)?;
|
||||
let uuid = self.persist.uuids.get(&id)?;
|
||||
let score = board.score(&uuid_text(*uuid), &objective.name)?;
|
||||
// numberFormatOrDefault(StyledFormat.NO_STYLE).
|
||||
let format = score
|
||||
.number_format
|
||||
.clone()
|
||||
.or_else(|| objective.number_format.clone())
|
||||
.unwrap_or(sb::NumberFormat::Styled(serde_json::json!({})));
|
||||
let mut t = Text::empty();
|
||||
t.push(format.format(score.value));
|
||||
t.push(Text::literal(" "));
|
||||
t.push(objective.display_text());
|
||||
Some(t)
|
||||
}
|
||||
pub(super) fn name_tag_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
|
||||
let target = self.mob_hit().map(|(i, _)| self.mobs[i].id);
|
||||
let forward = glam::DVec3::from_array(view_vector(self.yaw, self.pitch));
|
||||
let right = forward.cross(glam::DVec3::Y).normalize_or_zero();
|
||||
let up = right.cross(forward).normalize_or_zero();
|
||||
let white = self.res.atlas.font.white();
|
||||
let viewer = self.player_team();
|
||||
for m in &self.mobs {
|
||||
let Some(name) = m.custom_name.as_deref() else {
|
||||
continue;
|
||||
};
|
||||
if !(m.name_visible || Some(m.id) == target) || !m.alive() {
|
||||
if !m.alive() {
|
||||
continue;
|
||||
}
|
||||
let p = glam::DVec3::new(
|
||||
@@ -44,19 +66,48 @@ impl Game<'_> {
|
||||
m.previous.y + (m.position.y - m.previous.y) * alpha + f64::from(m.height()) + 0.5,
|
||||
m.previous.z + (m.position.z - m.previous.z) * alpha,
|
||||
);
|
||||
if p.distance_squared(camera) >= 64.0 * 64.0 {
|
||||
// The name tag distance (64) is measured to the entity.
|
||||
let distance_sqr =
|
||||
glam::DVec3::new(m.position.x, m.position.y, m.position.z).distance_squared(camera);
|
||||
if distance_sqr >= 64.0 * 64.0 {
|
||||
continue;
|
||||
}
|
||||
let o = (p - camera).as_vec3();
|
||||
let (r, u) = (right.as_vec3() * 0.025, up.as_vec3() * 0.025);
|
||||
// Text space: x right, y down (scale 0.025, -0.025).
|
||||
let at = |x: f32, y: f32| o + r * x - u * y;
|
||||
let width: f32 = name
|
||||
.chars()
|
||||
.map(|c| self.res.atlas.glyph(c).map_or(6.0, |g| g.1))
|
||||
.sum();
|
||||
let x0 = -(width / 2.0).trunc();
|
||||
let y0 = if name == "deadmau5" { -10.0 } else { 0.0 };
|
||||
let team = self.mob_team(m.id);
|
||||
// LivingEntityRenderer.shouldShowName (team rules included), then
|
||||
// MobRenderer: a visible name, or the mob under the crosshair.
|
||||
let invisible = sb::invisible_to(
|
||||
team,
|
||||
viewer,
|
||||
self.spectator(),
|
||||
m.has_effect("minecraft:invisibility"),
|
||||
);
|
||||
let view = sb::NameView {
|
||||
discrete: false,
|
||||
distance_sqr,
|
||||
invisible_to_viewer: invisible,
|
||||
hud_hidden: self.ui.hide_gui,
|
||||
is_camera: false,
|
||||
is_vehicle: self.mobs.iter().any(|o| o.extra.mount == Some(m.id)),
|
||||
};
|
||||
if !sb::name_shown(team, viewer, view) || !(m.name_visible || Some(m.id) == target) {
|
||||
continue;
|
||||
}
|
||||
// getDisplayName: the custom name in the team's prefix, suffix and colour.
|
||||
let shown = match team {
|
||||
Some(t) => t.formatted_name(Text::literal(name)),
|
||||
None => Text::literal(name),
|
||||
};
|
||||
let mut lines = Vec::new();
|
||||
// EntityRenderer.extractNameTags: the score shows within the
|
||||
// below-name distance (10), under the name.
|
||||
let mut lift = 0.0;
|
||||
if distance_sqr < 10.0 * 10.0
|
||||
&& let Some(score) = self.below_name_text(m.id)
|
||||
{
|
||||
lines.push((score, 0.0));
|
||||
lift = f64::from(9.0f32 * 1.15 * 0.025);
|
||||
}
|
||||
lines.push((shown, lift));
|
||||
let l = self.world.light(
|
||||
m.position.x.floor() as i32,
|
||||
(m.position.y + f64::from(m.height())).floor() as i32,
|
||||
@@ -64,48 +115,77 @@ impl Game<'_> {
|
||||
);
|
||||
let light = (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8);
|
||||
let away = forward.as_vec3() * 0.002;
|
||||
// `background`: unlit (vertex colour only) and a hair behind the text.
|
||||
let mut quad = |a: [f32; 4], uv: [f32; 4], color: u32, background: bool| {
|
||||
let corners = [(a[0], a[3]), (a[2], a[3]), (a[2], a[1]), (a[0], a[1])];
|
||||
let uvs = [
|
||||
[uv[0], uv[3]],
|
||||
[uv[2], uv[3]],
|
||||
[uv[2], uv[1]],
|
||||
[uv[0], uv[1]],
|
||||
];
|
||||
for ((x, y), uv) in corners.into_iter().zip(uvs) {
|
||||
out.push(Vertex {
|
||||
pos: (at(x, y) + if background { away } else { glam::Vec3::ZERO })
|
||||
.to_array(),
|
||||
uv,
|
||||
layer: if background { 2 } else { 0 },
|
||||
color,
|
||||
light,
|
||||
});
|
||||
}
|
||||
};
|
||||
// Background: Options.getBackgroundOpacity(0.25) black.
|
||||
quad(
|
||||
[x0 - 1.0, y0 - 1.0, x0 + width, y0 + 8.0],
|
||||
[white.u0, white.v0, white.u1, white.v1],
|
||||
0x40_00_00_00,
|
||||
true,
|
||||
);
|
||||
let mut x = x0;
|
||||
for ch in name.chars() {
|
||||
let Some((g, advance)) = self.res.atlas.glyph(ch) else {
|
||||
x += 6.0;
|
||||
continue;
|
||||
for (text, lift) in lines {
|
||||
let o = (p + glam::DVec3::new(0.0, lift, 0.0) - camera).as_vec3();
|
||||
let (r, u) = (right.as_vec3() * 0.025, up.as_vec3() * 0.025);
|
||||
// Text space: x right, y down (scale 0.025, -0.025).
|
||||
let at = |x: f32, y: f32| o + r * x - u * y;
|
||||
let chars: Vec<(char, u32)> = text
|
||||
.spans
|
||||
.iter()
|
||||
.flat_map(|s| {
|
||||
let rgb = s.style.color.unwrap_or(0xFF_FF_FF);
|
||||
// RGBA8, alpha in the top byte.
|
||||
let color = 0xFF00_0000
|
||||
| ((rgb & 0xFF) << 16)
|
||||
| (rgb & 0xFF00)
|
||||
| ((rgb >> 16) & 0xFF);
|
||||
s.text.chars().map(move |c| (c, color))
|
||||
})
|
||||
.collect();
|
||||
let width: f32 = chars
|
||||
.iter()
|
||||
.map(|(c, _)| self.res.atlas.glyph(*c).map_or(6.0, |g| g.1))
|
||||
.sum();
|
||||
let x0 = -(width / 2.0).trunc();
|
||||
let y0 = if text.plain() == "deadmau5" {
|
||||
-10.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
if ch != ' ' {
|
||||
quad(
|
||||
[x, y0, x + 8.0, y0 + 8.0],
|
||||
[g.u0, g.v0, g.u1, g.v1],
|
||||
0xFFFF_FFFF,
|
||||
false,
|
||||
);
|
||||
// `background`: unlit (vertex colour only) and a hair behind the text.
|
||||
let mut quad = |a: [f32; 4], uv: [f32; 4], color: u32, background: bool| {
|
||||
let corners = [(a[0], a[3]), (a[2], a[3]), (a[2], a[1]), (a[0], a[1])];
|
||||
let uvs = [
|
||||
[uv[0], uv[3]],
|
||||
[uv[2], uv[3]],
|
||||
[uv[2], uv[1]],
|
||||
[uv[0], uv[1]],
|
||||
];
|
||||
for ((x, y), uv) in corners.into_iter().zip(uvs) {
|
||||
out.push(Vertex {
|
||||
pos: (at(x, y) + if background { away } else { glam::Vec3::ZERO })
|
||||
.to_array(),
|
||||
uv,
|
||||
layer: if background { 2 } else { 0 },
|
||||
color,
|
||||
light,
|
||||
});
|
||||
}
|
||||
};
|
||||
// Background: Options.getBackgroundOpacity(0.25) black.
|
||||
quad(
|
||||
[x0 - 1.0, y0 - 1.0, x0 + width, y0 + 8.0],
|
||||
[white.u0, white.v0, white.u1, white.v1],
|
||||
0x40_00_00_00,
|
||||
true,
|
||||
);
|
||||
let mut x = x0;
|
||||
for (ch, color) in chars {
|
||||
let Some((g, advance)) = self.res.atlas.glyph(ch) else {
|
||||
x += 6.0;
|
||||
continue;
|
||||
};
|
||||
if ch != ' ' {
|
||||
quad(
|
||||
[x, y0, x + 8.0, y0 + 8.0],
|
||||
[g.u0, g.v0, g.u1, g.v1],
|
||||
color,
|
||||
false,
|
||||
);
|
||||
}
|
||||
x += advance;
|
||||
}
|
||||
x += advance;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,7 +20,8 @@ use std::collections::HashSet;
|
||||
/// What `ServerPlayer` last recorded for the criteria that follow the player.
|
||||
#[derive(Default)]
|
||||
pub(super) struct Recorded {
|
||||
health: Option<i32>,
|
||||
/// `lastRecordedHealthAndAbsorption` (compared as a float).
|
||||
health_and_absorption: Option<f32>,
|
||||
food: Option<i32>,
|
||||
air: Option<i32>,
|
||||
armor: Option<i32>,
|
||||
@@ -306,18 +307,29 @@ impl Game<'_> {
|
||||
});
|
||||
}
|
||||
}
|
||||
let display = self.player_display_comp();
|
||||
if let Some(p) = self.player.as_mut() {
|
||||
let health = (p.health.health() + p.health.absorption()).ceil() as i32;
|
||||
let health_and_absorption = p.health.health() + p.health.absorption();
|
||||
let food = p.health.food.food;
|
||||
// getArmorValue: the armor attribute rounded down.
|
||||
let armor = p
|
||||
.attribute("minecraft:armor")
|
||||
.or_else(|_| p.attribute("armor"))
|
||||
.unwrap_or(0.0)
|
||||
.ceil() as i32;
|
||||
.floor() as i32;
|
||||
let rec = &mut self.score.recorded;
|
||||
let board = &mut self.score.board;
|
||||
if rec.health_and_absorption != Some(health_and_absorption) {
|
||||
rec.health_and_absorption = Some(health_and_absorption);
|
||||
let value = health_and_absorption.ceil() as i32;
|
||||
board.for_all_objectives_with(
|
||||
sb::CRITERIA_HEALTH,
|
||||
PLAYER_NAME,
|
||||
Some(&display),
|
||||
|_| value,
|
||||
);
|
||||
}
|
||||
for (criteria, last, value) in [
|
||||
(sb::CRITERIA_HEALTH, &mut rec.health, health),
|
||||
(sb::CRITERIA_FOOD, &mut rec.food, food),
|
||||
// The air supply is full unless the player is drowning.
|
||||
(sb::CRITERIA_AIR, &mut rec.air, 300),
|
||||
@@ -327,7 +339,12 @@ impl Game<'_> {
|
||||
] {
|
||||
if *last != Some(value) {
|
||||
*last = Some(value);
|
||||
board.for_all_objectives(criteria, PLAYER_NAME, |_| value);
|
||||
board.for_all_objectives_with(
|
||||
criteria,
|
||||
PLAYER_NAME,
|
||||
Some(&display),
|
||||
|_| value,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -338,29 +355,39 @@ impl Game<'_> {
|
||||
}
|
||||
/// `ServerPlayer.die`: the death count.
|
||||
pub(super) fn score_player_died(&mut self) {
|
||||
let display = self.player_display_comp();
|
||||
let board = &mut self.score.board;
|
||||
board.for_all_objectives(sb::CRITERIA_DEATH_COUNT, PLAYER_NAME, |v| v + 1);
|
||||
board.for_all_objectives_with(sb::CRITERIA_DEATH_COUNT, PLAYER_NAME, Some(&display), |v| {
|
||||
v.wrapping_add(1)
|
||||
});
|
||||
// A respawned player has everything to record again.
|
||||
self.score.recorded = Recorded::default();
|
||||
}
|
||||
/// `ServerPlayer.awardKillScore`: total kills and the team kill counts.
|
||||
pub(super) fn score_player_killed(&mut self, victim: Target) {
|
||||
let victim_name = self.holder_name(victim);
|
||||
let display = self.player_display_comp();
|
||||
let board = &mut self.score.board;
|
||||
board.for_all_objectives(sb::CRITERIA_TOTAL_KILLS, PLAYER_NAME, |v| v + 1);
|
||||
let inc = |v: i32| v.wrapping_add(1);
|
||||
board.for_all_objectives_with(sb::CRITERIA_TOTAL_KILLS, PLAYER_NAME, Some(&display), inc);
|
||||
if victim == Target::Player {
|
||||
board.for_all_objectives(sb::CRITERIA_PLAYER_KILLS, PLAYER_NAME, |v| v + 1);
|
||||
board.for_all_objectives_with(
|
||||
sb::CRITERIA_PLAYER_KILLS,
|
||||
PLAYER_NAME,
|
||||
Some(&display),
|
||||
inc,
|
||||
);
|
||||
}
|
||||
let color_of =
|
||||
|board: &Scoreboard, name: &str| board.players_team(name).and_then(|t| t.color.clone());
|
||||
if let Some(victim_name) = victim_name {
|
||||
if let Some(color) = color_of(board, &victim_name) {
|
||||
let criteria = format!("teamkill.{color}");
|
||||
board.for_all_objectives(&criteria, PLAYER_NAME, |v| v + 1);
|
||||
board.for_all_objectives_with(&criteria, PLAYER_NAME, Some(&display), inc);
|
||||
}
|
||||
if let Some(color) = color_of(board, PLAYER_NAME) {
|
||||
let criteria = format!("killedByTeam.{color}");
|
||||
board.for_all_objectives(&criteria, &victim_name, |v| v + 1);
|
||||
board.for_all_objectives(&criteria, &victim_name, inc);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -369,9 +396,44 @@ impl Game<'_> {
|
||||
let Some(uuid) = self.persist.uuids.get(&id).copied() else {
|
||||
return;
|
||||
};
|
||||
let name = uuid_text(uuid);
|
||||
self.score.board.reset_all(&name);
|
||||
self.score.board.remove_from_team(&name);
|
||||
self.score.board.entity_removed(&uuid_text(uuid));
|
||||
}
|
||||
|
||||
// ---- teams in gameplay -----------------------------------------------------
|
||||
|
||||
/// `Entity.getTeam` of a mob (a mob joins a team by its UUID).
|
||||
pub(super) fn mob_team(&self, id: u32) -> Option<&sb::Team> {
|
||||
let uuid = self.persist.uuids.get(&id)?;
|
||||
self.score.board.players_team(&uuid_text(*uuid))
|
||||
}
|
||||
pub(super) fn player_team(&self) -> Option<&sb::Team> {
|
||||
self.score.board.players_team(PLAYER_NAME)
|
||||
}
|
||||
/// The mobs on the player's team (`isAlliedTo`).
|
||||
pub(super) fn player_allies(&self) -> HashSet<u32> {
|
||||
let Some(team) = self.player_team() else {
|
||||
return HashSet::new();
|
||||
};
|
||||
self.persist
|
||||
.uuids
|
||||
.iter()
|
||||
.filter(|(_, uuid)| team.players.contains(&uuid_text(**uuid)))
|
||||
.map(|(id, _)| *id)
|
||||
.collect()
|
||||
}
|
||||
/// `Player.getDisplayName`: the name with the team's prefix, suffix and colour.
|
||||
pub(super) fn player_display_comp(&self) -> Comp {
|
||||
let name = literal(PLAYER_NAME);
|
||||
match self.player_team() {
|
||||
Some(t) => t.formatted_name_comp(&name),
|
||||
None => name,
|
||||
}
|
||||
}
|
||||
pub(super) fn player_display_text(&self) -> Text {
|
||||
match self.player_team() {
|
||||
Some(t) => t.formatted_name(Text::literal(PLAYER_NAME)),
|
||||
None => Text::literal(PLAYER_NAME),
|
||||
}
|
||||
}
|
||||
|
||||
// ---- commands ------------------------------------------------------------
|
||||
|
||||
@@ -904,6 +904,9 @@ pub struct PlayerView {
|
||||
pub hero: bool,
|
||||
/// The player's UUID (villagers' gossip is keyed by it).
|
||||
pub uuid: [i32; 4],
|
||||
/// The mobs on the player's team (`isAlliedTo`): combat targeting
|
||||
/// leaves the player alone.
|
||||
pub allies: std::sync::Arc<std::collections::HashSet<u32>>,
|
||||
}
|
||||
pub struct MobWorld<'a> {
|
||||
pub world: &'a World,
|
||||
|
||||
@@ -397,7 +397,8 @@ impl Mob {
|
||||
/// creative, within range scaled by visibility, optionally visible.
|
||||
pub fn can_target_player(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool {
|
||||
let Some(p) = &w.player else { return false };
|
||||
if !p.alive || p.creative {
|
||||
// TargetingConditions.isCombat: never an ally.
|
||||
if !p.alive || p.creative || p.allies.contains(&self.id) {
|
||||
return false;
|
||||
}
|
||||
let mut visibility = 1.0;
|
||||
|
||||
Reference in New Issue
Block a user