Experience orbs: wider pickup area, merging, and lava bounce
This commit is contained in:
@@ -385,8 +385,29 @@ pub struct ExperienceOrb {
|
||||
pub value: u32,
|
||||
pub age: u32,
|
||||
pub on_ground: bool,
|
||||
/// `ExperienceOrb.count`: orbs merged into this one; each pickup gives
|
||||
/// `value` once and takes one off.
|
||||
pub count: u32,
|
||||
/// `Entity.tickCount`, which paces `ExperienceOrb.scanForMerges`.
|
||||
pub ticks: u32,
|
||||
}
|
||||
impl ExperienceOrb {
|
||||
pub fn bounds(&self) -> Aabb {
|
||||
let h = 0.25;
|
||||
Aabb::new(
|
||||
Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
|
||||
Vec3::new(
|
||||
self.position.x + h,
|
||||
self.position.y + 0.5,
|
||||
self.position.z + h,
|
||||
),
|
||||
)
|
||||
}
|
||||
/// `ExperienceOrb.canMerge(orb, id, value)` for an orb that is not removed:
|
||||
/// the same value and ids a multiple of 40 apart.
|
||||
pub fn can_merge(&self, id: u32, value: u32) -> bool {
|
||||
self.value == value && (self.id as i32).wrapping_sub(id as i32) % 40 == 0
|
||||
}
|
||||
/// ExperienceOrb.getExperienceValue: the largest orb size not above `value`.
|
||||
pub fn split(value: u32) -> u32 {
|
||||
[2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]
|
||||
@@ -416,7 +437,9 @@ impl ExperienceOrb {
|
||||
facts: &BlockFacts,
|
||||
collision: &BlockCollisionRegistry<'_>,
|
||||
player: Option<[f64; 3]>,
|
||||
next_float: &mut dyn FnMut() -> f32,
|
||||
) -> bool {
|
||||
self.ticks += 1;
|
||||
self.previous = self.position;
|
||||
let block = world.block(
|
||||
self.position.x.floor() as i32,
|
||||
@@ -432,6 +455,14 @@ impl ExperienceOrb {
|
||||
} else {
|
||||
self.velocity.y -= 0.03;
|
||||
}
|
||||
if facts.get(block).fluid == Fluid::Lava {
|
||||
// ExperienceOrb.tick: lava throws the orb back out.
|
||||
self.velocity = Vec3::new(
|
||||
f64::from((next_float() - next_float()) * 0.2),
|
||||
f64::from(0.2f32),
|
||||
f64::from((next_float() - next_float()) * 0.2),
|
||||
);
|
||||
}
|
||||
if let Some(p) = player {
|
||||
let d = [
|
||||
(p[0] - self.position.x) / 8.0,
|
||||
@@ -449,15 +480,7 @@ impl ExperienceOrb {
|
||||
);
|
||||
}
|
||||
}
|
||||
let h = 0.25;
|
||||
let bounds = Aabb::new(
|
||||
Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
|
||||
Vec3::new(
|
||||
self.position.x + h,
|
||||
self.position.y + 0.5,
|
||||
self.position.z + h,
|
||||
),
|
||||
);
|
||||
let bounds = self.bounds();
|
||||
let mut scene = SceneCollisions {
|
||||
world,
|
||||
binding: collision,
|
||||
@@ -494,6 +517,31 @@ impl ExperienceOrb {
|
||||
self.age < 6000
|
||||
}
|
||||
}
|
||||
/// `ExperienceOrb.scanForMerges`, run by each orb on `tickCount % 20 == 1`:
|
||||
/// it absorbs the orbs that `canMerge` within 0.5 blocks of its box,
|
||||
/// adding their counts and keeping the smaller age.
|
||||
pub fn merge_orbs(orbs: &mut Vec<ExperienceOrb>) {
|
||||
let mut removed = vec![false; orbs.len()];
|
||||
for i in 0..orbs.len() {
|
||||
if removed[i] || orbs[i].ticks % 20 != 1 {
|
||||
continue;
|
||||
}
|
||||
let area = orbs[i].bounds().inflate(Vec3::new(0.5, 0.5, 0.5));
|
||||
for j in 0..orbs.len() {
|
||||
if j != i
|
||||
&& !removed[j]
|
||||
&& orbs[j].can_merge(orbs[i].id, orbs[i].value)
|
||||
&& orbs[j].bounds().intersects(area)
|
||||
{
|
||||
orbs[i].count += orbs[j].count;
|
||||
orbs[i].age = orbs[i].age.min(orbs[j].age);
|
||||
removed[j] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut removed = removed.into_iter();
|
||||
orbs.retain(|_| !removed.next().unwrap_or(false));
|
||||
}
|
||||
/// Player experience (Player.giveExperiencePoints / getXpNeededForNextLevel).
|
||||
#[derive(Clone, Copy, Debug, Default)]
|
||||
pub struct Experience {
|
||||
|
||||
@@ -1043,18 +1043,18 @@ pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
|
||||
("Health", Tag::Short(5)),
|
||||
("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
|
||||
("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
|
||||
("Count", Tag::Int(1)),
|
||||
("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
tag
|
||||
}
|
||||
/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
|
||||
/// One orb with its merged `Count`.
|
||||
pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
|
||||
let Some(position) = position(tag) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
|
||||
let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
|
||||
let orb = ExperienceOrb {
|
||||
id: 0,
|
||||
position,
|
||||
@@ -1063,8 +1063,10 @@ pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
|
||||
value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
|
||||
age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
|
||||
on_ground: flag(tag, "OnGround"),
|
||||
count,
|
||||
ticks: 0,
|
||||
};
|
||||
vec![orb; count]
|
||||
vec![orb]
|
||||
}
|
||||
|
||||
/// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
|
||||
@@ -1840,7 +1842,7 @@ mod tests {
|
||||
assert_eq!(number(tag.get("Health")), Some(5));
|
||||
}
|
||||
#[test]
|
||||
fn orbs_expand_their_count() {
|
||||
fn orbs_keep_their_count() {
|
||||
let o = ExperienceOrb {
|
||||
id: 0,
|
||||
position: Vec3::new(1.0, 2.0, 3.0),
|
||||
@@ -1849,12 +1851,14 @@ mod tests {
|
||||
value: 7,
|
||||
age: 3,
|
||||
on_ground: false,
|
||||
count: 3,
|
||||
ticks: 0,
|
||||
};
|
||||
let mut tag = orb_to_nbt(&o, [0; 4]);
|
||||
put(&mut tag, "Count", Tag::Int(3));
|
||||
let tag = orb_to_nbt(&o, [0; 4]);
|
||||
let back = orbs_from_nbt(&tag);
|
||||
assert_eq!(back.len(), 3);
|
||||
assert_eq!(back.len(), 1);
|
||||
assert_eq!(back[0].value, 7);
|
||||
assert_eq!(back[0].count, 3);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -8905,8 +8905,29 @@ impl Game<'_> {
|
||||
while value > 0 {
|
||||
let v = ExperienceOrb::split(value);
|
||||
value -= v;
|
||||
let _merge_id = self.world.random.next_int_bound(40);
|
||||
self.add_orb(at, v);
|
||||
let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
|
||||
self.award_orb(at, v, merge_id);
|
||||
}
|
||||
}
|
||||
/// `ExperienceOrb.tryMergeToExisting`: an orb of the same value within a
|
||||
/// 1 block box of `at`, whose id is a multiple of 40 from `merge_id`, takes
|
||||
/// the new one as one more in its count (and restarts its age); otherwise
|
||||
/// a fresh orb spawns.
|
||||
fn award_orb(&mut self, at: [f64; 3], value: u32, merge_id: i32) {
|
||||
let centre = Vec3::new(at[0], at[1], at[2]);
|
||||
let half = Vec3::new(0.5, 0.5, 0.5);
|
||||
let area = Aabb::new(centre.subtract(half), centre.add_vector(half));
|
||||
// A server's orbs are its own; a LAN or server guest only shows them.
|
||||
let target = self.remote.is_none().then(|| {
|
||||
self.orbs
|
||||
.iter_mut()
|
||||
.find(|o| o.can_merge(merge_id as u32, value) && o.bounds().intersects(area))
|
||||
});
|
||||
if let Some(Some(orb)) = target {
|
||||
orb.count += 1;
|
||||
orb.age = 0;
|
||||
} else {
|
||||
self.add_orb(at, value);
|
||||
}
|
||||
}
|
||||
/// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
|
||||
@@ -8928,6 +8949,8 @@ impl Game<'_> {
|
||||
value,
|
||||
age: 0,
|
||||
on_ground: false,
|
||||
count: 1,
|
||||
ticks: 0,
|
||||
});
|
||||
}
|
||||
fn can_place_used_fire(&mut self, target: [i32; 3]) -> bool {
|
||||
@@ -9004,18 +9027,31 @@ impl Game<'_> {
|
||||
}),
|
||||
);
|
||||
}
|
||||
// Player.aiStep: the pickup area is the box inflated by (1, 0.5, 1).
|
||||
let bounds = player.map(|p| {
|
||||
let w = f64::from(p.dimensions.width) / 2.0;
|
||||
(
|
||||
[p.position.x - w, p.position.y, p.position.z - w],
|
||||
[
|
||||
p.position.x + w,
|
||||
p.position.y + f64::from(p.dimensions.height),
|
||||
p.position.z + w,
|
||||
p.position.x - w - 1.0,
|
||||
p.position.y - 0.5,
|
||||
p.position.z - w - 1.0,
|
||||
],
|
||||
[
|
||||
p.position.x + w + 1.0,
|
||||
p.position.y + f64::from(p.dimensions.height) + 0.5,
|
||||
p.position.z + w + 1.0,
|
||||
],
|
||||
)
|
||||
});
|
||||
let mut orbs = std::mem::take(&mut self.orbs);
|
||||
// An orb has no random of its own here: lava draws from one made on
|
||||
// first use, apart from the level stream.
|
||||
let mut lava_random = None;
|
||||
let mut next_float = || {
|
||||
lava_random
|
||||
.get_or_insert_with(dispenser::entity_random)
|
||||
.next_float()
|
||||
};
|
||||
orbs.retain_mut(|o| {
|
||||
let distance = |feet: &[f64; 3]| -> f64 {
|
||||
(feet[0] - o.position.x).powi(2)
|
||||
@@ -9027,12 +9063,22 @@ impl Game<'_> {
|
||||
.filter(|(feet, _)| distance(feet) < 64.0)
|
||||
.min_by(|a, b| distance(&a.0).total_cmp(&distance(&b.0)))
|
||||
.map(|(_, target)| *target);
|
||||
o.tick(&self.world, self.res.facts(), self.collision, target)
|
||||
o.tick(
|
||||
&self.world,
|
||||
self.res.facts(),
|
||||
self.collision,
|
||||
target,
|
||||
&mut next_float,
|
||||
)
|
||||
});
|
||||
// ExperienceOrb.scanForMerges runs on the server only.
|
||||
if self.remote.is_none() {
|
||||
horizon_client::entities::merge_orbs(&mut orbs);
|
||||
}
|
||||
let mut gained = 0;
|
||||
let mut taken = Vec::new();
|
||||
if let Some((min, max)) = bounds {
|
||||
orbs.retain(|o| {
|
||||
orbs.retain_mut(|o| {
|
||||
let touching = o.position.x + 0.25 > min[0]
|
||||
&& o.position.x - 0.25 < max[0]
|
||||
&& o.position.y + 0.5 > min[1]
|
||||
@@ -9040,11 +9086,13 @@ impl Game<'_> {
|
||||
&& o.position.z + 0.25 > min[2]
|
||||
&& o.position.z - 0.25 < max[2];
|
||||
if touching && self.xp_delay == 0 {
|
||||
// ExperienceOrb.playerTouch: one orb every 2 ticks.
|
||||
// ExperienceOrb.playerTouch: one orb every 2 ticks; a
|
||||
// merged orb gives its value once per count.
|
||||
self.xp_delay = 2;
|
||||
gained += o.value;
|
||||
taken.push(o.clone());
|
||||
return false;
|
||||
o.count -= 1;
|
||||
return o.count > 0;
|
||||
}
|
||||
true
|
||||
});
|
||||
|
||||
@@ -1682,6 +1682,8 @@ impl Game<'_> {
|
||||
value: 0,
|
||||
age: 0,
|
||||
on_ground: false,
|
||||
count: 1,
|
||||
ticks: 0,
|
||||
});
|
||||
name = Text::translate("entity.minecraft.experience_orb", &[]);
|
||||
}
|
||||
|
||||
@@ -155,6 +155,8 @@ mod tests {
|
||||
value: 1,
|
||||
age: 0,
|
||||
on_ground: false,
|
||||
count: 1,
|
||||
ticks: 0,
|
||||
}))
|
||||
}
|
||||
|
||||
|
||||
@@ -1269,6 +1269,8 @@ impl Game<'_> {
|
||||
value: 1,
|
||||
age: 0,
|
||||
on_ground: false,
|
||||
count: 1,
|
||||
ticks: 0,
|
||||
});
|
||||
}
|
||||
if let Some(t) = mob_type {
|
||||
|
||||
@@ -171,8 +171,8 @@ pub(super) struct Spawn {
|
||||
pub(super) struct Spill {
|
||||
pub(super) spawns: Vec<Spawn>,
|
||||
/// Experience orbs (`ExperienceOrb.award`): where and how much, each
|
||||
/// having drawn its merge id from the level random.
|
||||
pub(super) orbs: Vec<([f64; 3], u32)>,
|
||||
/// and the merge id it drew from the level random.
|
||||
pub(super) orbs: Vec<([f64; 3], u32, i32)>,
|
||||
/// Block entities the behaviour removed, for the game's own follow-ups
|
||||
/// (open screens, playing songs).
|
||||
pub(super) removed: Vec<([i32; 3], BlockEntity)>,
|
||||
@@ -342,8 +342,8 @@ impl GameLevel<'_> {
|
||||
while amount > 0 {
|
||||
let value = removal::orb_value(amount);
|
||||
amount -= value;
|
||||
let _merge_id = self.world.random.next_int_bound(40);
|
||||
self.spill.orbs.push((at, value));
|
||||
let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
|
||||
self.spill.orbs.push((at, value, merge_id));
|
||||
}
|
||||
}
|
||||
/// `BlockEntity.preRemoveSideEffects` and `removeBlockEntity` for the block
|
||||
@@ -579,8 +579,8 @@ impl Game<'_> {
|
||||
let motion = s.motion.unwrap_or_else(new_item_motion);
|
||||
self.spawn_item(s.stack, s.pos, motion, s.delay);
|
||||
}
|
||||
for (at, value) in spill.orbs {
|
||||
self.add_orb(at, value);
|
||||
for (at, value, merge_id) in spill.orbs {
|
||||
self.award_orb(at, value, merge_id);
|
||||
}
|
||||
for (pos, entity) in spill.removed {
|
||||
let key = (pos[0], pos[1], pos[2]);
|
||||
|
||||
Reference in New Issue
Block a user