1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use std::io::Result as Res;

use endio::{Deserialize, Serialize};
use endio_bit::BEBitWriter;
use lu_packets_derive::{BitVariantTests, ReplicaSerde};

use crate::common::{LuVarWString, ObjId};
use crate::world::gm::client::{PetAbilityType, PetModerationStatus};
use super::{ComponentConstruction, ComponentProtocol, ComponentSerialization};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
#[repr(u8)]
pub enum PossessionType {
	NoPossession,
	AttachedVisible,
	NotAttachedVisible,
	NotAttachedNotVisible,
}

#[derive(Debug, PartialEq, ReplicaSerde)]
pub struct TamedPetInfo {
	pub pet_name_moderation_status: PetModerationStatus,
	pub pet_name: LuVarWString<u8>,
	pub owner_name: LuVarWString<u8>,
}

#[derive(Debug, PartialEq, ReplicaSerde)]
pub struct PetConstructionInfo {
	/// todo: bitflag
	pub pet_state: u32,
	pub ability_in_use: PetAbilityType,
	pub interaction_id: Option<ObjId>,
	pub owner_id: Option<ObjId>,
	pub tamed_pet_info: Option<TamedPetInfo>,
}

#[derive(BitVariantTests, Debug, PartialEq, ReplicaSerde)]
pub struct PetConstruction {
	pub pet_construction_info: Option<PetConstructionInfo>,
}

impl ComponentConstruction for PetConstruction {
	fn ser(&self, writer: &mut BEBitWriter<Vec<u8>>) -> Res<()> {
		self.serialize(writer)
	}
}

pub type PetSerialization = PetConstruction;

impl ComponentSerialization for PetSerialization {
	fn ser(&self, writer: &mut BEBitWriter<Vec<u8>>) -> Res<()> {
		self.serialize(writer)
	}
}

pub struct PetProtocol;

impl ComponentProtocol for PetProtocol {
	type Construction = PetConstruction;
	type Serialization = PetSerialization;
}