use bytes::Bytes;
use ghast_protocol::nbt::RawNbt;
use ghast_protocol::{DecodeError, Reader};
use crate::entity::{Effect, Item};
use crate::store::{Entities, Event, PlayerInfo};
pub(crate) type R<T> = Result<T, DecodeError>;
#[inline]
pub(crate) fn angle(b: i8) -> f32 {
(i32::from(b) * 360) as f32 / 256.0
}
pub(crate) fn own_nbt(n: Option<RawNbt>) -> Option<Bytes> {
n.map(|n| Bytes::copy_from_slice(n.as_bytes()))
}
pub(crate) fn legacy_item(s: ghast_protocol::types::slot::legacy::Slot) -> Option<Item> {
s.0.map(|i| Item {
id: i32::from(i.id),
count: i.count,
damage: i.damage,
nbt: own_nbt(i.nbt),
})
}
pub(crate) fn modern_item(s: ghast_protocol::types::slot::modern::Slot) -> Option<Item> {
s.0.map(|i| Item {
id: i.id,
count: i.count,
damage: 0,
nbt: own_nbt(i.nbt),
})
}
pub(crate) fn own_str(r: &mut Reader<'_>) -> R<Box<str>> {
Ok(Box::from(&*r.read_string()?))
}
pub(crate) fn player_info(store: &mut Entities, r: &mut Reader<'_>) -> R<()> {
let action = r.read_varint()?;
let n = r.read_varint()?;
let n = r.check_count(i64::from(n), 16)?;
for _ in 0..n {
let uuid = r.read_uuid()?;
match action {
0 => {
let name = r.read_string()?;
let props = r.read_varint()?;
let props = r.check_count(i64::from(props), 3)?;
let mut textures = None;
for _ in 0..props {
if store.config.skins {
let key = r.read_string()?;
let value = r.read_string()?;
if &*key == "textures" {
textures = Some(Box::<str>::from(&*value));
}
} else {
skip_string(r)?;
skip_string(r)?;
}
if r.read_bool()? {
skip_string(r)?;
}
}
let game_mode = r.read_varint()?;
let ping = r.read_varint()?;
if store.lite_mode() {
if r.read_bool()? {
skip_string(r)?;
}
store.lite_add(uuid, &name, game_mode, 0, true);
continue;
}
let display_name = if r.read_bool()? {
Some(own_str(r)?)
} else {
None
};
store.players.insert(
uuid,
PlayerInfo {
name: Box::from(&*name),
game_mode,
ping,
display_name,
textures,
display_name_nbt: None,
listed: true,
list_order: 0,
generation: 0,
},
);
}
1 => {
let g = r.read_varint()?;
if let Some(p) = store.players.get_mut(&uuid) {
p.game_mode = g;
}
store.lite_game_mode(&uuid, g);
}
2 => {
let ping = r.read_varint()?;
if let Some(p) = store.players.get_mut(&uuid) {
p.ping = ping;
}
}
3 => {
let d = if r.read_bool()? {
Some(own_str(r)?)
} else {
None
};
if let Some(p) = store.players.get_mut(&uuid) {
p.display_name = d;
}
}
4 => {
store.tab_remove(&uuid);
}
_ => return Err(DecodeError::Invalid("unknown player_info action")),
}
}
store.event(Event::PlayerList);
Ok(())
}
pub(crate) fn skip_string(r: &mut Reader<'_>) -> R<()> {
let n = r.read_len_varint(r.remaining())?;
r.skip(n)
}
pub(crate) fn for_each_varint(r: &mut Reader<'_>, mut f: impl FnMut(i32)) -> R<()> {
let n = r.read_varint()?;
let n = r.check_count(i64::from(n), 1)?;
for _ in 0..n {
f(r.read_varint()?);
}
Ok(())
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct IdMask([u64; 4]);
impl IdMask {
pub(crate) fn add(&mut self, ids: &[i32]) {
for &id in ids {
if (0..256).contains(&id) {
self.0[(id >> 6) as usize] |= 1 << (id & 63);
}
}
}
#[inline]
pub(crate) fn contains(&self, id: i32) -> bool {
(0..256).contains(&id) && self.0[(id >> 6) as usize] & (1 << (id & 63)) != 0
}
pub(crate) fn iter(&self) -> impl Iterator<Item = i32> + '_ {
(0..256).filter(|&id| self.contains(id))
}
}
pub(crate) fn set_effect(s: &mut Entities, eid: i32, effect: Effect) -> bool {
match s.map.get_mut(&eid) {
Some(e) => {
let effects = &mut e.links_mut().effects;
match effects.iter_mut().find(|x| x.id == effect.id) {
Some(x) => *x = effect,
None => effects.push(effect),
}
s.event(Event::Effects(eid));
true
}
None => false,
}
}
pub(crate) fn remove_effect(s: &mut Entities, eid: i32, effect: u8) -> bool {
match s.map.get_mut(&eid) {
Some(e) => {
if let Some(l) = &mut e.links {
l.effects.retain(|x| x.id != effect);
}
e.tidy_links();
s.event(Event::Effects(eid));
true
}
None => false,
}
}