def check_flying(self):
entity = self.connection.entity
flags = entity.flags
# in the air when, not gliding, not "on ground", not swimming, not
# climbing
if not (flags & GLIDER_FLAG or is_bit_set(entity.physics_flags, 0)
or is_bit_set(entity.physics_flags, 1)
or is_bit_set(entity.physics_flags, 2) or entity.hp <= 0):
self.air_time += self.time_since_update
if self.air_time > self.max_air_time:
self.remove_cheater('flying hack')
return False
else:
self.air_time = 0
def check_flying(self):
entity = self.connection.entity
flags = entity.flags
# in the air when, not gliding, not "on ground", not swimming, not
# climbing
if not (flags & GLIDER_FLAG
or is_bit_set(entity.physics_flags, 0)
or is_bit_set(entity.physics_flags, 1)
or is_bit_set(entity.physics_flags, 2)
or entity.hp <= 0):
self.air_time += self.time_since_update
if self.air_time > self.max_air_time:
self.remove_cheater('flying hack')
return False
else:
self.air_time = 0
def has_illegal_flags(self):
entity_data = self.connection.entity_data
# This is when holding control, doesnt need to be on a wall
FLAGS_1_CLIMBING = 0
FLAGS_1_ATTACKING = 2
FLAGS_1_GLIDER_ACTIVE = 4
FLAGS_2_LANTERN_ON = 1
FLAGS_2_RANGER_STEALTH = 2
flags_1 = entity_data.flags_1
flags_2 = entity_data.flags_2
if (is_bit_set(flags_2, FLAGS_2_RANGER_STEALTH) and
entity_data.class_type != RANGER_CLASS):
self.log("none ranger class using ranger stealth. class={classid}"
.format(classid=entity_data.class_type),
LOG_LEVEL_VERBOSE)
return True
# Glider resetting attack animations bug
# Rapidly switching between will be seen as bug abusing.
if is_bit_set(flags_1, FLAGS_1_ATTACKING):
self.last_attacking = time.time()
self.attack_count += 1
if is_bit_set(flags_1, FLAGS_1_GLIDER_ACTIVE):
self.last_glider_active = time.time()
self.glider_count += 1
# Reset if either attacking or gliding has not happend for a time
if (time.time() - self.last_glider_active > 0.75 or
time.time() - self.last_attacking > 0.75):
self.glider_count = 0
self.attack_count = 0
if (self.glider_count > self.glider_abuse_count and
self.attack_count > self.glider_abuse_count):
self.log("glider reset attack animation bug abuse."
.format(classid=entity_data.class_type),
LOG_LEVEL_VERBOSE)
return True
return False
def check_flying(self):
entity_data = self.connection.entity_data
flags_1 = entity_data.flags_1
# in the air when, not gliding, not "on ground", not swimming, not
# climbing
if not (
is_bit_set(flags_1, FLAGS_1_GLIDER_ACTIVE)
or is_bit_set(entity_data.physics_flags, 0)
or is_bit_set(entity_data.physics_flags, 2)
or is_bit_set(entity_data.physics_flags, 3)
or entity_data.hp <= 0
):
self.air_time += self.time_since_update
if self.air_time > self.max_air_time:
self.remove_cheater("flying hack")
return False
else:
self.air_time = 0
def on_entity_update(self, event):
entity = self.connection.entity
if self.last_entity_update is None:
self.last_entity_update = self.loop.time()
if not self.connection.has_joined:
self.remove_cheater('full entity update not sent')
return False
self.time_since_update = self.loop.time() - self.last_entity_update
self.last_entity_update = self.loop.time()
self.last_mana = self.mana
self.last_health = self.health
self.mana = entity.mp
self.health = entity.hp
if is_bit_set(event.mask, 7):
if self.check_hostile_type() is False:
return False
if is_bit_set(event.mask, 27):
if self.check_max_health() is False:
return False
if self.loop.time() - self.last_hit_check > 1.0:
self.last_hit_check = self.loop.time()
if self.check_last_hit() is False:
return False
# if self.check_speed() is False:
# return False
if self.check_flying() is False:
return False
if not self.is_dead and self.health <= 0:
self.is_dead = True
self.on_death()
if self.health > 0 and self.is_dead:
self.is_dead = False
def has_illegal_flags(self):
entity_data = self.connection.entity_data
# This is when holding control, doesnt need to be on a wall
flags_1 = entity_data.flags_1
flags_2 = entity_data.flags_2
if (is_bit_set(flags_2, FLAGS_2_RANGER_STEALTH)
and entity_data.class_type != RANGER_CLASS):
self.log(
"none ranger class using ranger stealth. class={classid}".
format(classid=entity_data.class_type), LOG_LEVEL_VERBOSE)
return True
# Glider resetting attack animations bug
# Rapidly switching between will be seen as bug abusing.
if is_bit_set(flags_1, FLAGS_1_ATTACKING):
self.last_attacking = reactor.seconds()
self.attack_count += 1
if is_bit_set(flags_1, FLAGS_1_GLIDER_ACTIVE):
self.last_glider_active = reactor.seconds()
self.glider_count += 1
# Reset if either attacking or gliding has not happend for a time
if (reactor.seconds() - self.last_glider_active > 0.75
or reactor.seconds() - self.last_attacking > 0.75):
self.glider_count = 0
self.attack_count = 0
if (self.glider_count > self.glider_abuse_count
and self.attack_count > self.glider_abuse_count):
self.log(
"glider reset attack animation bug abuse.".format(
classid=entity_data.class_type), LOG_LEVEL_VERBOSE)
return True
return False
def on_entity_update(self, event):
entity_data = self.connection.entity_data
self.time_since_update = reactor.seconds() - self.last_entity_update
self.last_entity_update = reactor.seconds()
self.last_mana = self.mana
self.last_health = self.health
self.mana = entity_data.mp
self.health = entity_data.hp
if is_bit_set(event.mask, 7):
if self.check_hostile_type() is False:
return False
if is_bit_set(event.mask, 27):
if self.check_max_health() is False:
return False
if reactor.seconds() - self.last_hit_check > 1.0:
self.last_hit_check = reactor.seconds()
if self.check_last_hit() is False:
return False
# if self.check_speed() is False:
# return False
if self.check_flying() is False:
return False
if not self.is_dead and self.health <= 0:
self.is_dead = True
self.on_death()
if self.health > 0 and self.is_dead:
self.is_dead = False
def on_entity_update(self, event):
entity_data = self.connection.entity_data
self.time_since_update = reactor.seconds() - self.last_entity_update
self.last_entity_update = reactor.seconds()
self.last_mana = self.mana
self.last_health = self.health
self.mana = entity_data.mp
self.health = entity_data.hp
if is_bit_set(event.mask, 7):
if self.check_hostile_type() is False:
return False
if is_bit_set(event.mask, 27):
if self.check_max_health() is False:
return False
if reactor.seconds() - self.last_hit_check > 1.0:
self.last_hit_check = reactor.seconds()
if self.check_last_hit() is False:
return False
# if self.check_speed() is False:
# return False
if self.check_flying() is False:
return False
if not self.is_dead and self.health <= 0:
self.is_dead = True
self.on_death()
if self.health > 0 and self.is_dead:
self.is_dead = False
def is_multiplier_set(mask):
return is_bit_set(mask, MULTIPLIER_BIT)
def is_charged_mp_set(mask):
return is_bit_set(mask, CHARGED_MP_BIT)
def get_masked_size(mask):
size = 0
if is_bit_set(mask, 0):
size += 24
if is_bit_set(mask, 1):
size += 12
if is_bit_set(mask, 2):
size += 12
if is_bit_set(mask, 3):
size += 12
if is_bit_set(mask, 4):
size += 12
if is_bit_set(mask, 5):
size += 4
if is_bit_set(mask, 6):
size += 4
if is_bit_set(mask, 7):
size += 1
if is_bit_set(mask, 8):
size += 4
if is_bit_set(mask, 9):
size += 1
if is_bit_set(mask, 10):
size += 4
if is_bit_set(mask, 11):
size += 4
if is_bit_set(mask, 12):
size += 4
if is_bit_set(mask, 13):
size += 172
if is_bit_set(mask, 14):
size += 2
if is_bit_set(mask, 15):
size += 4
if is_bit_set(mask, 16):
size += 4
if is_bit_set(mask, 17):
size += 4
if is_bit_set(mask, 18):
size += 4
if is_bit_set(mask, 19):
size += 4
if is_bit_set(mask, 20):
size += 4
if is_bit_set(mask, 21):
size += 1
if is_bit_set(mask, 22):
size += 1
if is_bit_set(mask, 23):
size += 4
if is_bit_set(mask, 24):
size += 12
if is_bit_set(mask, 25):
size += 12
if is_bit_set(mask, 26):
size += 12
if is_bit_set(mask, 27):
size += 4
if is_bit_set(mask, 28):
size += 4
if is_bit_set(mask, 29):
size += 4
if is_bit_set(mask, 30):
size += 20
if is_bit_set(mask, 31):
size += 1
if is_bit_set(mask, 32):
size += 1
if is_bit_set(mask, 33):
size += 4
if is_bit_set(mask, 34):
size += 4
if is_bit_set(mask, 35):
size += 8
if is_bit_set(mask, 36):
size += 8
if is_bit_set(mask, 37):
size += 1
if is_bit_set(mask, 38):
size += 4
if is_bit_set(mask, 39):
size += 12
if is_bit_set(mask, 40):
size += 24
if is_bit_set(mask, 41):
size += 12
if is_bit_set(mask, 42):
size += 1
if is_bit_set(mask, 43):
size += 280
if is_bit_set(mask, 44):
size += 3640
if is_bit_set(mask, 45):
size += 16
if is_bit_set(mask, 46):
size += 44
if is_bit_set(mask, 47):
size += 4
def get_masked_size(mask):
size = 0
if is_pos_set(mask):
size += 24
if is_orient_set(mask):
size += 12
if is_vel_set(mask):
size += 12
if is_accel_set(mask):
size += 12
if is_extra_vel_set(mask):
size += 12
if is_look_pitch_set(mask):
size += 4
if is_bit_set(mask, 6):
size += 4
if is_bit_set(mask, 7):
size += 1
if is_bit_set(mask, 8):
size += 4
if is_mode_set(mask):
size += 1
if is_bit_set(mask, 10):
size += 4
if is_bit_set(mask, 11):
size += 4
if is_bit_set(mask, 12):
size += 4
if is_appearance_set(mask):
size += 172
if is_flags_set(mask):
size += 2
if is_bit_set(mask, 15):
size += 4
if is_bit_set(mask, 16):
size += 4
if is_bit_set(mask, 17):
size += 4
if is_bit_set(mask, 18):
size += 4
if is_bit_set(mask, 19):
size += 4
if is_bit_set(mask, 20):
size += 4
if is_class_set(mask):
size += 1
if is_bit_set(mask, 22):
size += 1
if is_charged_mp_set(mask):
size += 4
if is_bit_set(mask, 24):
size += 12
if is_bit_set(mask, 25):
size += 12
if is_bit_set(mask, 26):
size += 12
if is_bit_set(mask, 27):
size += 4
if is_bit_set(mask, 28):
size += 4
if is_bit_set(mask, 29):
size += 4
if is_multiplier_set(mask):
size += 20
if is_bit_set(mask, 31):
size += 1
if is_bit_set(mask, 32):
size += 1
if is_level_set(mask):
size += 4
if is_bit_set(mask, 34):
size += 4
if is_bit_set(mask, 35):
size += 8
if is_bit_set(mask, 36):
size += 8
if is_bit_set(mask, 37):
size += 1
if is_bit_set(mask, 38):
size += 4
if is_bit_set(mask, 39):
size += 12
if is_bit_set(mask, 40):
size += 24
if is_bit_set(mask, 41):
size += 12
if is_bit_set(mask, 42):
size += 1
if is_consumable_set(mask):
size += 280
if is_equipment_set(mask):
size += 3640
if is_name_set(mask):
size += 16
if is_skill_set(mask):
size += 44
if is_bit_set(mask, 47):
size += 4
return size
def is_skill_set(mask):
return is_bit_set(mask, SKILL_BIT)
def is_equipment_set(mask):
return is_bit_set(mask, EQUIPMENT_BIT)
def is_extra_vel_set(mask):
return is_bit_set(mask, EXTRA_VEL_BIT)
def is_accel_set(mask):
return is_bit_set(mask, ACCEL_BIT)
def is_vel_set(mask):
return is_bit_set(mask, VEL_BIT)
def is_orient_set(mask):
return is_bit_set(mask, ORIENT_BIT)
def is_pos_set(mask):
return is_bit_set(mask, POS_BIT)
def is_level_set(mask):
return is_bit_set(mask, LEVEL_BIT)
def is_consumable_set(mask):
return is_bit_set(mask, CONSUMABLE_BIT)
def is_look_pitch_set(mask):
return is_bit_set(mask, LOOK_PITCH_BIT)
def is_name_set(mask):
return is_bit_set(mask, NAME_BIT)
def is_mode_set(mask):
return is_bit_set(mask, MODE_BIT)
def read_masked_data(entity, reader):
mask = reader.read_uint64()
if is_pos_set(mask):
entity.pos = reader.read_qvec3()
if is_orient_set(mask):
entity.body_roll = reader.read_float()
entity.body_pitch = reader.read_float()
entity.body_yaw = reader.read_float()
if is_vel_set(mask):
entity.velocity = reader.read_vec3()
if is_accel_set(mask):
entity.accel = reader.read_vec3()
if is_extra_vel_set(mask):
entity.extra_vel = reader.read_vec3()
if is_look_pitch_set(mask):
entity.look_pitch = reader.read_float()
if is_bit_set(mask, 6):
entity.physics_flags = reader.read_uint32()
if is_bit_set(mask, 7):
entity.hostile_type = reader.read_uint8()
if is_bit_set(mask, 8):
entity.entity_type = reader.read_uint32()
if is_mode_set(mask):
entity.current_mode = reader.read_uint8()
if is_bit_set(mask, 10):
entity.last_shoot_time = reader.read_uint32()
if is_bit_set(mask, 11):
entity.hit_counter = reader.read_uint32()
if is_bit_set(mask, 12):
entity.last_hit_time = reader.read_uint32()
if is_appearance_set(mask):
entity.appearance.read(reader)
if is_flags_set(mask):
entity.flags_1 = reader.read_uint8()
entity.flags_2 = reader.read_uint8()
if is_bit_set(mask, 15):
entity.roll_time = reader.read_uint32()
if is_bit_set(mask, 16):
entity.stun_time = reader.read_int32()
if is_bit_set(mask, 17):
entity.slowed_time = reader.read_uint32()
if is_bit_set(mask, 18):
entity.make_blue_time = reader.read_uint32()
if is_bit_set(mask, 19):
entity.speed_up_time = reader.read_uint32()
if is_bit_set(mask, 20):
entity.show_patch_time = reader.read_float()
if is_class_set(mask):
entity.class_type = reader.read_uint8()
if is_bit_set(mask, 22):
entity.specialization = reader.read_uint8()
if is_charged_mp_set(mask):
entity.charged_mp = reader.read_float()
if is_bit_set(mask, 24):
entity.not_used_1 = reader.read_uint32()
entity.not_used_2 = reader.read_uint32()
entity.not_used_3 = reader.read_uint32()
if is_bit_set(mask, 25):
entity.not_used_4 = reader.read_uint32()
entity.not_used_5 = reader.read_uint32()
entity.not_used_6 = reader.read_uint32()
if is_bit_set(mask, 26):
entity.ray_hit = reader.read_vec3()
if is_bit_set(mask, 27):
entity.hp = reader.read_float()
if is_bit_set(mask, 28):
entity.mp = reader.read_float()
if is_bit_set(mask, 29):
entity.block_power = reader.read_float()
if is_multiplier_set(mask):
entity.max_hp_multiplier = reader.read_float()
entity.shoot_speed = reader.read_float()
entity.damage_multiplier = reader.read_float()
entity.armor_multiplier = reader.read_float()
entity.resi_multiplier = reader.read_float()
if is_bit_set(mask, 31):
entity.not_used7 = reader.read_uint8()
if is_bit_set(mask, 32):
entity.not_used8 = reader.read_uint8()
if is_level_set(mask):
entity.level = reader.read_uint32()
if is_bit_set(mask, 34):
entity.current_xp = reader.read_uint32()
if is_bit_set(mask, 35):
entity.parent_owner = reader.read_uint64()
if is_bit_set(mask, 36):
entity.unknown_or_not_used1 = reader.read_uint32()
entity.unknown_or_not_used2 = reader.read_uint32()
if is_bit_set(mask, 37):
entity.unknown_or_not_used3 = reader.read_uint8()
if is_bit_set(mask, 38):
entity.unknown_or_not_used4 = reader.read_uint32()
if is_bit_set(mask, 39):
entity.unknown_or_not_used5 = reader.read_uint32()
entity.not_used11 = reader.read_uint32()
entity.not_used12 = reader.read_uint32()
if is_bit_set(mask, 40):
entity.spawn_pos = reader.read_qvec3()
if is_bit_set(mask, 41):
entity.not_used20 = reader.read_uint32()
entity.not_used21 = reader.read_uint32()
entity.not_used22 = reader.read_uint32()
if is_bit_set(mask, 42):
entity.not_used19 = reader.read_uint8()
if is_consumable_set(mask):
entity.consumable.read(reader)
if is_equipment_set(mask):
for item in entity.equipment:
item.read(reader)
if is_name_set(mask):
entity.name = reader.read_ascii(16)
if is_skill_set(mask):
entity.skills = []
for _ in xrange(11):
entity.skills.append(reader.read_uint32())
if is_bit_set(mask, 47):
entity.mana_cubes = reader.read_uint32()
return mask
def read_masked_data(entity, reader):
mask = reader.read_uint64()
if is_bit_set(mask, 0):
entity.x = reader.read_int64()
entity.y = reader.read_int64()
entity.z = reader.read_int64()
if is_bit_set(mask, 1):
entity.body_roll = reader.read_float()
entity.body_pitch = reader.read_float()
entity.body_yaw = reader.read_float()
if is_bit_set(mask, 2):
entity.velocity = reader.read_vec3()
if is_bit_set(mask, 3):
entity.accel = reader.read_vec3()
if is_bit_set(mask, 4):
entity.extra_vel = reader.read_vec3()
if is_bit_set(mask, 5):
entity.look_pitch = reader.read_float()
if is_bit_set(mask, 6):
entity.physics_flags = reader.read_uint32()
if is_bit_set(mask, 7):
entity.speed_flags = reader.read_uint8()
if is_bit_set(mask, 8):
entity.entity_type = reader.read_uint32()
if is_bit_set(mask, 9):
entity.current_mode = reader.read_uint8()
if is_bit_set(mask, 10):
entity.last_shoot_time = reader.read_uint32()
if is_bit_set(mask, 11):
entity.hit_counter = reader.read_uint32()
if is_bit_set(mask, 12):
entity.last_hit_time = reader.read_uint32()
if is_bit_set(mask, 13):
entity.appearance.read(reader)
if is_bit_set(mask, 14):
entity.flags_1 = reader.read_uint8()
entity.flags_2 = reader.read_uint8()
if is_bit_set(mask, 15):
entity.roll_time = reader.read_uint32()
if is_bit_set(mask, 16):
entity.stun_time = reader.read_int32()
if is_bit_set(mask, 17):
entity.slowed_time = reader.read_uint32()
if is_bit_set(mask, 18):
entity.make_blue_time = reader.read_uint32()
if is_bit_set(mask, 19):
entity.speed_up_time = reader.read_uint32()
if is_bit_set(mask, 20):
entity.show_patch_time = reader.read_float()
if is_bit_set(mask, 21):
entity.class_type = reader.read_uint8()
if is_bit_set(mask, 22):
entity.specialization = reader.read_uint8()
if is_bit_set(mask, 23):
entity.charged_mp = reader.read_float()
if is_bit_set(mask, 24):
entity.not_used_1 = reader.read_uint32()
entity.not_used_2 = reader.read_uint32()
entity.not_used_3 = reader.read_uint32()
if is_bit_set(mask, 25):
entity.not_used_4 = reader.read_uint32()
entity.not_used_5 = reader.read_uint32()
entity.not_used_6 = reader.read_uint32()
if is_bit_set(mask, 26):
entity.ray_hit = reader.read_vec3()
if is_bit_set(mask, 27):
entity.hp = reader.read_float()
if is_bit_set(mask, 28):
entity.mp = reader.read_float()
if is_bit_set(mask, 29):
entity.block_power = reader.read_float()
if is_bit_set(mask, 30):
entity.max_hp_multiplier = reader.read_float()
entity.shoot_speed = reader.read_float()
entity.damage_multiplier = reader.read_float()
entity.armor_multiplier = reader.read_float()
entity.resi_multiplier = reader.read_float()
if is_bit_set(mask, 31):
entity.not_used7 = reader.read_uint8()
if is_bit_set(mask, 32):
entity.not_used8 = reader.read_uint8()
if is_bit_set(mask, 33):
entity.character_level = reader.read_uint32()
if is_bit_set(mask, 34):
entity.current_xp = reader.read_uint32()
if is_bit_set(mask, 35):
entity.not_used9 = reader.read_uint32()
entity.not_used10 = reader.read_uint32()
if is_bit_set(mask, 36):
entity.unknown_or_not_used1 = reader.read_uint32()
entity.unknown_or_not_used2 = reader.read_uint32()
if is_bit_set(mask, 37):
entity.unknown_or_not_used3 = reader.read_uint8()
if is_bit_set(mask, 38):
entity.unknown_or_not_used4 = reader.read_uint32()
if is_bit_set(mask, 39):
entity.unknown_or_not_used5 = reader.read_uint32()
entity.not_used11 = reader.read_uint32()
entity.not_used12 = reader.read_uint32()
if is_bit_set(mask, 40):
entity.not_used13 = reader.read_uint32()
entity.not_used14 = reader.read_uint32()
entity.not_used15 = reader.read_uint32()
entity.not_used16 = reader.read_uint32()
entity.not_used17 = reader.read_uint32()
entity.not_used18 = reader.read_uint32()
if is_bit_set(mask, 41):
entity.not_used20 = reader.read_uint32()
entity.not_used21 = reader.read_uint32()
entity.not_used22 = reader.read_uint32()
if is_bit_set(mask, 42):
entity.not_used19 = reader.read_uint8()
if is_bit_set(mask, 43):
entity.item_data.read(reader)
if is_bit_set(mask, 44):
for item in entity.equipment:
item.read(reader)
if is_bit_set(mask, 45):
entity.name = reader.read_string(16)
if is_bit_set(mask, 46):
entity.skills = []
for _ in xrange(11):
entity.skills.append(reader.read_uint32())
if is_bit_set(mask, 47):
entity.ice_block_four = reader.read_uint32()
def write_masked_data(entity, writer, mask=None):
if mask is None:
mask = 0x0000FFFFFFFFFFFF
writer.write_uint64(mask)
if is_pos_set(mask):
writer.write_qvec3(entity.pos)
if is_orient_set(mask):
writer.write_float(entity.body_roll)
writer.write_float(entity.body_pitch)
writer.write_float(entity.body_yaw)
if is_vel_set(mask):
writer.write_vec3(entity.velocity)
if is_accel_set(mask):
writer.write_vec3(entity.accel)
if is_extra_vel_set(mask):
writer.write_vec3(entity.extra_vel)
if is_look_pitch_set(mask):
writer.write_float(entity.look_pitch)
if is_bit_set(mask, 6):
writer.write_uint32(entity.physics_flags)
if is_bit_set(mask, 7):
writer.write_uint8(entity.hostile_type)
if is_bit_set(mask, 8):
writer.write_uint32(entity.entity_type)
if is_mode_set(mask):
writer.write_uint8(entity.current_mode)
if is_bit_set(mask, 10):
writer.write_uint32(entity.last_shoot_time)
if is_bit_set(mask, 11):
writer.write_uint32(entity.hit_counter)
if is_bit_set(mask, 12):
writer.write_uint32(entity.last_hit_time)
if is_appearance_set(mask):
entity.appearance.write(writer)
if is_flags_set(mask):
writer.write_uint8(entity.flags_1)
writer.write_uint8(entity.flags_2)
if is_bit_set(mask, 15):
writer.write_uint32(entity.roll_time)
if is_bit_set(mask, 16):
writer.write_int32(entity.stun_time)
if is_bit_set(mask, 17):
writer.write_uint32(entity.slowed_time)
if is_bit_set(mask, 18):
writer.write_uint32(entity.make_blue_time)
if is_bit_set(mask, 19):
writer.write_uint32(entity.speed_up_time)
if is_bit_set(mask, 20):
writer.write_float(entity.show_patch_time)
if is_class_set(mask):
writer.write_uint8(entity.class_type)
if is_bit_set(mask, 22):
writer.write_uint8(entity.specialization)
if is_charged_mp_set(mask):
writer.write_float(entity.charged_mp)
if is_bit_set(mask, 24):
writer.write_uint32(entity.not_used_1)
writer.write_uint32(entity.not_used_2)
writer.write_uint32(entity.not_used_3)
if is_bit_set(mask, 25):
writer.write_uint32(entity.not_used_4)
writer.write_uint32(entity.not_used_5)
writer.write_uint32(entity.not_used_6)
if is_bit_set(mask, 26):
writer.write_vec3(entity.ray_hit)
if is_bit_set(mask, 27):
writer.write_float(entity.hp)
if is_bit_set(mask, 28):
writer.write_float(entity.mp)
if is_bit_set(mask, 29):
writer.write_float(entity.block_power)
if is_multiplier_set(mask):
writer.write_float(entity.max_hp_multiplier)
writer.write_float(entity.shoot_speed)
writer.write_float(entity.damage_multiplier)
writer.write_float(entity.armor_multiplier)
writer.write_float(entity.resi_multiplier)
if is_bit_set(mask, 31):
writer.write_uint8(entity.not_used7)
if is_bit_set(mask, 32):
writer.write_uint8(entity.not_used8)
if is_level_set(mask):
writer.write_uint32(entity.level)
if is_bit_set(mask, 34):
writer.write_uint32(entity.current_xp)
if is_bit_set(mask, 35):
writer.write_uint64(entity.parent_owner)
if is_bit_set(mask, 36):
writer.write_uint32(entity.unknown_or_not_used1)
writer.write_uint32(entity.unknown_or_not_used2)
if is_bit_set(mask, 37):
writer.write_uint8(entity.unknown_or_not_used3)
if is_bit_set(mask, 38):
writer.write_uint32(entity.unknown_or_not_used4)
if is_bit_set(mask, 39):
writer.write_uint32(entity.unknown_or_not_used5)
writer.write_uint32(entity.not_used11)
writer.write_uint32(entity.not_used12)
if is_bit_set(mask, 40):
writer.write_qvec3(entity.spawn_pos)
if is_bit_set(mask, 41):
writer.write_uint32(entity.not_used20)
writer.write_uint32(entity.not_used21)
writer.write_uint32(entity.not_used22)
if is_bit_set(mask, 42):
writer.write_uint8(entity.not_used19)
if is_consumable_set(mask):
entity.consumable.write(writer)
if is_equipment_set(mask):
for item in entity.equipment:
item.write(writer)
if is_name_set(mask):
writer.write_ascii(entity.name, 16)
if is_skill_set(mask):
for item in entity.skills:
writer.write_uint32(item)
if is_bit_set(mask, 47):
writer.write_uint32(entity.mana_cubes)
def is_flags_set(mask):
return is_bit_set(mask, FLAGS_BIT)
def is_appearance_set(mask):
return is_bit_set(mask, APPEARANCE_BIT)
def is_class_set(mask):
return is_bit_set(mask, CLASS_BIT)
