mbEditorPro/mbEditorPro2.0/arcane/ArcVisual.py

#  • ▌ ▄ ·. ▄▄▄▄·     ▄▄▄ .·▄▄▄▄  ▪  ▄▄▄▄▄      ▄▄▄       ▄▄▄·▄▄▄
#  ·██ ▐███▪▐█ ▀█▪    ▀▄.▀·██▪ ██ ██ •██  ▪     ▀▄ █·    ▐█ ▄█▀▄ █·▪
#  ▐█ ▌▐▌▐█·▐█▀▀█▄    ▐▀▀▪▄▐█· ▐█▌▐█· ▐█.▪ ▄█▀▄ ▐▀▀▄      ██▀·▐▀▀▄  ▄█▀▄
#  ██ ██▌▐█▌██▄▪▐█    ▐█▄▄▌██. ██ ▐█▌ ▐█▌·▐█▌.▐▌▐█•█▌    ▐█▪·•▐█•█▌▐█▌.▐▌
#  ▀▀  █▪▀▀▀·▀▀▀▀      ▀▀▀ ▀▀▀▀▀• ▀▀▀ ▀▀▀  ▀█▄▀▪.▀  ▀    .▀   .▀  ▀ ▀█▄▀▪
#                Magicbane Emulator Project © 2013 - 2022
#                           www.magicbane.com
#


from base64 import b64decode, b64encode
from collections import OrderedDict

from arcane.util import ResStream

EFFETCT_TO_STRING = {
    0: 'PARTICLE',
    1: 'LIGHTNING',
    2: 'GEOMETRY',
}

STRING_TO_EFFECT = {value: key for key, value in EFFETCT_TO_STRING.items()}


class ArcParticle:
    def load_binary(self, stream: ResStream):
        self.particle_attached_bone = stream.read_dword()
        self.particle_count = stream.read_dword()
        self.particle_size = stream.read_float()
        self.particle_life = stream.read_float()
        self.particle_life_rand = stream.read_float()
        self.particle_shape_and_pos = stream.read_dword()
        self.particle_emitter_scale = stream.read_float()
        self.particle_pos_offset = stream.read_tuple()
        self.particle_ppos_reference = stream.read_tuple()
        self.particle_initial_velocities = stream.read_dword()
        self.particle_velocity_scale = stream.read_float()
        self.particle_vel_reference = stream.read_tuple()
        self.particle_dir_random = stream.read_float()
        self.particle_spd_random = stream.read_float()
        self.particle_initial_rot = stream.read_float()
        self.particle_initial_rot_random = stream.read_float()
        self.particle_incremental_rot = stream.read_float()
        self.particle_incremental_rot_random = stream.read_float()
        self.particle_color_keys = [
            [
                stream.read_float(),
                stream.read_float(),
                stream.read_float(),
                stream.read_float(),
            ] for _ in range(5)
        ]
        self.particle_color_keytimes = [stream.read_float() for _ in range(5)]
        self.particle_size_keys = [stream.read_float() for _ in range(5)]
        self.particle_targettype = stream.read_dword()
        self.particle_lifetime = stream.read_float()
        self.particle_texture = stream.read_dword()
        self.particle_blend_type = stream.read_dword()
        self.particle_attractor_bone = stream.read_dword()
        self.particle_directional_grav = stream.read_tuple()
        self.particle_field_function = stream.read_dword()
        self.particle_gravity_strength = stream.read_float()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.particle_attached_bone)
        stream.write_dword(self.particle_count)
        stream.write_float(self.particle_size)
        stream.write_float(self.particle_life)
        stream.write_float(self.particle_life_rand)
        stream.write_dword(self.particle_shape_and_pos)
        stream.write_float(self.particle_emitter_scale)
        stream.write_tuple(self.particle_pos_offset)
        stream.write_tuple(self.particle_ppos_reference)
        stream.write_dword(self.particle_initial_velocities)
        stream.write_float(self.particle_velocity_scale)
        stream.write_tuple(self.particle_vel_reference)
        stream.write_float(self.particle_dir_random)
        stream.write_float(self.particle_spd_random)
        stream.write_float(self.particle_initial_rot)
        stream.write_float(self.particle_initial_rot_random)
        stream.write_float(self.particle_incremental_rot)
        stream.write_float(self.particle_incremental_rot_random)
        for i in range(5):
            stream.write_float(self.particle_color_keys[i][0])
            stream.write_float(self.particle_color_keys[i][1])
            stream.write_float(self.particle_color_keys[i][2])
            stream.write_float(self.particle_color_keys[i][3])
        for i in range(5):
            stream.write_float(self.particle_color_keytimes[i])
        for i in range(5):
            stream.write_float(self.particle_size_keys[i])
        stream.write_dword(self.particle_targettype)
        stream.write_float(self.particle_lifetime)
        stream.write_dword(self.particle_texture)
        stream.write_dword(self.particle_blend_type)
        stream.write_dword(self.particle_attractor_bone)
        stream.write_tuple(self.particle_directional_grav)
        stream.write_dword(self.particle_field_function)
        stream.write_float(self.particle_gravity_strength)

    def load_json(self, data):
        self.particle_attached_bone = data['particle_attached_bone']
        self.particle_count = data['particle_count']
        self.particle_size = data['particle_size']
        self.particle_life = data['particle_life']
        self.particle_life_rand = data['particle_life_rand']
        self.particle_shape_and_pos = data['particle_shape_and_pos']
        self.particle_emitter_scale = data['particle_emitter_scale']
        self.particle_pos_offset = data['particle_pos_offset']
        self.particle_ppos_reference = data['particle_ppos_reference']
        self.particle_initial_velocities = data['particle_initial_velocities']
        self.particle_velocity_scale = data['particle_velocity_scale']
        self.particle_vel_reference = data['particle_vel_reference']
        self.particle_dir_random = data['particle_dir_random']
        self.particle_spd_random = data['particle_spd_random']
        self.particle_initial_rot = data['particle_initial_rot']
        self.particle_initial_rot_random = data['particle_initial_rot_random']
        self.particle_incremental_rot = data['particle_incremental_rot']
        self.particle_incremental_rot_random = data['particle_incremental_rot_random']
        self.particle_color_keys = data['particle_color_keys']
        self.particle_color_keytimes = data['particle_color_keytimes']
        self.particle_size_keys = data['particle_size_keys']
        self.particle_targettype = data['particle_targettype']
        self.particle_lifetime = data['particle_lifetime']
        self.particle_texture = data['particle_texture']
        self.particle_blend_type = data['particle_blend_type']
        self.particle_attractor_bone = data['particle_attractor_bone']
        self.particle_directional_grav = data['particle_directional_grav']
        self.particle_field_function = data['particle_field_function']
        self.particle_gravity_strength = data['particle_gravity_strength']

    def save_json(self):
        data = OrderedDict()
        data['particle_attached_bone'] = self.particle_attached_bone
        data['particle_count'] = self.particle_count
        data['particle_size'] = self.particle_size
        data['particle_life'] = self.particle_life
        data['particle_life_rand'] = self.particle_life_rand
        data['particle_shape_and_pos'] = self.particle_shape_and_pos
        data['particle_emitter_scale'] = self.particle_emitter_scale
        data['particle_pos_offset'] = self.particle_pos_offset
        data['particle_ppos_reference'] = self.particle_ppos_reference
        data['particle_initial_velocities'] = self.particle_initial_velocities
        data['particle_velocity_scale'] = self.particle_velocity_scale
        data['particle_vel_reference'] = self.particle_vel_reference
        data['particle_dir_random'] = self.particle_dir_random
        data['particle_spd_random'] = self.particle_spd_random
        data['particle_initial_rot'] = self.particle_initial_rot
        data['particle_initial_rot_random'] = self.particle_initial_rot_random
        data['particle_incremental_rot'] = self.particle_incremental_rot
        data['particle_incremental_rot_random'] = self.particle_incremental_rot_random
        data['particle_color_keys'] = self.particle_color_keys
        data['particle_color_keytimes'] = self.particle_color_keytimes
        data['particle_size_keys'] = self.particle_size_keys
        data['particle_targettype'] = self.particle_targettype
        data['particle_lifetime'] = self.particle_lifetime
        data['particle_texture'] = self.particle_texture
        data['particle_blend_type'] = self.particle_blend_type
        data['particle_attractor_bone'] = self.particle_attractor_bone
        data['particle_directional_grav'] = self.particle_directional_grav
        data['particle_field_function'] = self.particle_field_function
        data['particle_gravity_strength'] = self.particle_gravity_strength
        return data


class ArcLightning:
    def load_binary(self, stream: ResStream):
        self.lightning_texture = stream.read_dword()
        self.lightning_src_bone = stream.read_dword()
        self.lightning_dst_bone = stream.read_dword()
        self.lightning_width = stream.read_float()
        self.lightning_random_factor = stream.read_float()
        self.lightning_sine_factor = stream.read_float()
        self.lightning_sine_phase = stream.read_float()
        self.lightning_sine_phase_rep = stream.read_float()
        self.lightning_length = stream.read_float()
        self.lightning_random_move_speed = stream.read_float()
        self.lightning_color = stream.read_tuple()
        self.lightning_lifetime = stream.read_float()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.lightning_texture)
        stream.write_dword(self.lightning_src_bone)
        stream.write_dword(self.lightning_dst_bone)
        stream.write_float(self.lightning_width)
        stream.write_float(self.lightning_random_factor)
        stream.write_float(self.lightning_sine_factor)
        stream.write_float(self.lightning_sine_phase)
        stream.write_float(self.lightning_sine_phase_rep)
        stream.write_float(self.lightning_length)
        stream.write_float(self.lightning_random_move_speed)
        stream.write_tuple(self.lightning_color)
        stream.write_float(self.lightning_lifetime)

    def load_json(self, data):
        self.lightning_texture = data['lightning_texture']
        self.lightning_src_bone = data['lightning_src_bone']
        self.lightning_dst_bone = data['lightning_dst_bone']
        self.lightning_width = data['lightning_width']
        self.lightning_random_factor = data['lightning_random_factor']
        self.lightning_sine_factor = data['lightning_sine_factor']
        self.lightning_sine_phase = data['lightning_sine_phase']
        self.lightning_sine_phase_rep = data['lightning_sine_phase_rep']
        self.lightning_length = data['lightning_length']
        self.lightning_random_move_speed = data['lightning_random_move_speed']
        self.lightning_color = data['lightning_color']
        self.lightning_lifetime = data['lightning_lifetime']

    def save_json(self):
        data = OrderedDict()
        data['lightning_texture'] = self.lightning_texture
        data['lightning_src_bone'] = self.lightning_src_bone
        data['lightning_dst_bone'] = self.lightning_dst_bone
        data['lightning_width'] = self.lightning_width
        data['lightning_random_factor'] = self.lightning_random_factor
        data['lightning_sine_factor'] = self.lightning_sine_factor
        data['lightning_sine_phase'] = self.lightning_sine_phase
        data['lightning_sine_phase_rep'] = self.lightning_sine_phase_rep
        data['lightning_length'] = self.lightning_length
        data['lightning_random_move_speed'] = self.lightning_random_move_speed
        data['lightning_color'] = self.lightning_color
        data['lightning_lifetime'] = self.lightning_lifetime
        return data


class ArcGeometry:
    def load_binary(self, stream: ResStream):
        self.geometry_texture = stream.read_dword()
        self.geometry_src_bone = stream.read_dword()
        self.geometry_lifetime = stream.read_float()
        self.geometry_tex_trans_x = stream.read_float()
        self.geometry_tex_trans_y = stream.read_float()
        self.geometry_tex_rot = stream.read_float()
        self.geometry_grow = stream.read_tuple()
        self.geometry_tesselation = stream.read_float()
        self.geometry_size = stream.read_tuple()
        self.geometry_geo_rot_x = stream.read_float()
        self.geometry_fade_falloff = stream.read_float()
        self.geometry_fadein = stream.read_float()
        self.geometry_fadeout = stream.read_float()
        self.geometry_color = [stream.read_float() for _ in range(4)]
        self.geometry_type = stream.read_dword()
        self.geometry_texture_proj = stream.read_dword()
        self.geometry_fade_dir = stream.read_dword()
        self.geometry_offset = stream.read_tuple()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.geometry_texture)
        stream.write_dword(self.geometry_src_bone)
        stream.write_float(self.geometry_lifetime)
        stream.write_float(self.geometry_tex_trans_x)
        stream.write_float(self.geometry_tex_trans_y)
        stream.write_float(self.geometry_tex_rot)
        stream.write_tuple(self.geometry_grow)
        stream.write_float(self.geometry_tesselation)
        stream.write_tuple(self.geometry_size)
        stream.write_float(self.geometry_geo_rot_x)
        stream.write_float(self.geometry_fade_falloff)
        stream.write_float(self.geometry_fadein)
        stream.write_float(self.geometry_fadeout)
        for i in range(4):
            stream.write_float(self.geometry_color[i])
        stream.write_dword(self.geometry_type)
        stream.write_dword(self.geometry_texture_proj)
        stream.write_dword(self.geometry_fade_dir)
        stream.write_tuple(self.geometry_offset)

    def load_json(self, data):
        self.geometry_texture = data['geometry_texture']
        self.geometry_src_bone = data['geometry_src_bone']
        self.geometry_lifetime = data['geometry_lifetime']
        self.geometry_tex_trans_x = data['geometry_tex_trans_x']
        self.geometry_tex_trans_y = data['geometry_tex_trans_y']
        self.geometry_tex_rot = data['geometry_tex_rot']
        self.geometry_grow = data['geometry_grow']
        self.geometry_tesselation = data['geometry_tesselation']
        self.geometry_size = data['geometry_size']
        self.geometry_geo_rot_x = data['geometry_geo_rot_x']
        self.geometry_fade_falloff = data['geometry_fade_falloff']
        self.geometry_fadein = data['geometry_fadein']
        self.geometry_fadeout = data['geometry_fadeout']
        self.geometry_color = data['geometry_color']
        self.geometry_type = data['geometry_type']
        self.geometry_texture_proj = data['geometry_texture_proj']
        self.geometry_fade_dir = data['geometry_fade_dir']
        self.geometry_offset = data['geometry_offset']

    def save_json(self):
        data = OrderedDict()
        data['geometry_texture'] = self.geometry_texture
        data['geometry_src_bone'] = self.geometry_src_bone
        data['geometry_lifetime'] = self.geometry_lifetime
        data['geometry_tex_trans_x'] = self.geometry_tex_trans_x
        data['geometry_tex_trans_y'] = self.geometry_tex_trans_y
        data['geometry_tex_rot'] = self.geometry_tex_rot
        data['geometry_grow'] = self.geometry_grow
        data['geometry_tesselation'] = self.geometry_tesselation
        data['geometry_size'] = self.geometry_size
        data['geometry_geo_rot_x'] = self.geometry_geo_rot_x
        data['geometry_fade_falloff'] = self.geometry_fade_falloff
        data['geometry_fadein'] = self.geometry_fadein
        data['geometry_fadeout'] = self.geometry_fadeout
        data['geometry_color'] = self.geometry_color
        data['geometry_type'] = self.geometry_type
        data['geometry_texture_proj'] = self.geometry_texture_proj
        data['geometry_fade_dir'] = self.geometry_fade_dir
        data['geometry_offset'] = self.geometry_offset
        return data


class ArcVisualEffect:
    def load_binary(self, stream: ResStream):
        self.effect_type = stream.read_dword()
        self.effect_time = stream.read_float()

        if self.effect_type == 0:
            self.effect = ArcParticle()
        elif self.effect_type == 1:
            self.effect = ArcLightning()
        elif self.effect_type == 2:
            self.effect = ArcGeometry()
        self.effect.load_binary(stream)

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.effect_type)
        stream.write_float(self.effect_time)
        self.effect.save_binary(stream)

    def load_json(self, data):
        self.effect_type = STRING_TO_EFFECT[data['effect_type']]
        self.effect_time = data['effect_time']
        if self.effect_type == 0:
            self.effect = ArcParticle()
        elif self.effect_type == 1:
            self.effect = ArcLightning()
        elif self.effect_type == 2:
            self.effect = ArcGeometry()
        self.effect.load_json(data['effect'])

    def save_json(self):
        data = OrderedDict()
        data['effect_type'] = EFFETCT_TO_STRING[self.effect_type]
        data['effect_time'] = self.effect_time
        data['effect'] = self.effect.save_json()
        return data


class ArcVisual:
    def load_binary(self, stream: ResStream):
        num_effects = stream.read_dword()

        self.vfx_fail = None
        if num_effects == 1617156728:
            stream.buffer.seek(0, 0)
            self.vfx_fail = stream.buffer.read()
            return

        self.vfx_duration = stream.read_float()
        self.vfx_effects = [ArcVisualEffect() for _ in range(num_effects)]
        for effect in self.vfx_effects:
            effect.load_binary(stream)

    def save_binary(self, stream: ResStream):
        if self.vfx_fail:
            stream.buffer.write(self.vfx_fail)
            return

        stream.write_dword(len(self.vfx_effects))
        stream.write_float(self.vfx_duration)
        for effect in self.vfx_effects:
            effect.save_binary(stream)

    def load_json(self, data):
        self.vfx_fail = data.get('vfx_fail')
        if self.vfx_fail:
            self.vfx_fail = b64decode(self.vfx_fail)
            return

        self.vfx_duration = data['vfx_duration']
        self.vfx_effects = []
        for effect_data in data['vfx_effects']:
            effect = ArcVisualEffect()
            effect.load_json(effect_data)
            self.vfx_effects.append(effect)

    def save_json(self):
        data = OrderedDict()
        if self.vfx_fail:
            data['vfx_fail'] = b64encode(self.vfx_fail).decode()
            return data

        data['vfx_duration'] = self.vfx_duration
        data['vfx_effects'] = []
        for effect in self.vfx_effects:
            data['vfx_effects'].append(effect.save_json())
        return data