public override void Init(MyComponentDefinitionBase definition)
        {
            base.Init(definition);

            var craftDefinition = definition as MyCraftingComponentBasicDefinition;

            System.Diagnostics.Debug.Assert(craftDefinition != null, "Trying to initialize crafting component from wrong definition type?");


            if (craftDefinition != null)
            {
                ActionSound = new MySoundPair(craftDefinition.ActionSound);
                m_craftingSpeedMultiplier = craftDefinition.CraftingSpeedMultiplier;

                foreach (var blueprintClass in craftDefinition.AvailableBlueprintClasses)
                {
                    var classDefinition = MyDefinitionManager.Static.GetBlueprintClass(blueprintClass);
                    System.Diagnostics.Debug.Assert(classDefinition != null, blueprintClass + " blueprint class definition was not found.");
                    if (classDefinition != null)
                    {
                        m_blueprintClasses.Add(classDefinition);
                    }
                }
            }
        }

 public MyWeaponAmmoData(int rateOfFire, string soundName, int shotsInBurst)
 {
     this.RateOfFire = rateOfFire;
     this.ShotsInBurst = shotsInBurst;
     this.ShootSound = new MySoundPair(soundName);
     this.ShootIntervalInMiliseconds = (int)(1000 / (RateOfFire * oneSixtieth));
 }

 public ImpactSounds(float mass, string soundCue, float minVelocity, float maxVolumeVelocity)
 {
     this.Mass = mass;
     this.SoundCue = new MySoundPair(soundCue);
     this.minVelocity = minVelocity;
     this.maxVolumeVelocity = maxVolumeVelocity;
 }

        private bool m_willStartSound; // will start sound in updateaftersimulation

        #endregion Fields

        #region Constructors

        public MySoundBlock()
            : base()
        {
            #if XB1 // XB1_SYNC_NOREFLECTION
            m_soundRadius = SyncType.CreateAndAddProp<float>();
            m_volume = SyncType.CreateAndAddProp<float>();
            m_cueId = SyncType.CreateAndAddProp<MyCueId>();
            m_loopPeriod = SyncType.CreateAndAddProp<float>();
            #endif // XB1
            CreateTerminalControls();

            m_soundPair = new MySoundPair();

            m_soundEmitterIndex = 0;
            m_soundEmitters = new MyEntity3DSoundEmitter[EMITTERS_NUMBER];
            for (int i = 0; i < EMITTERS_NUMBER; i++)
            {
                m_soundEmitters[i] = new MyEntity3DSoundEmitter(this);
                m_soundEmitters[i].Force3D = true;
            }

            m_volume.ValueChanged += (x) => VolumeChanged();
            m_soundRadius.ValueChanged += (x) => RadiusChanged();
            m_cueId.ValueChanged += (x) => SelectionChanged();
        }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_WeaponDefinition;
            MyDebug.AssertDebug(ob != null);

            this.WeaponAmmoDatas = new MyWeaponAmmoData[Enum.GetValues(typeof(MyAmmoType)).Length];
            this.NoAmmoSound = new MySoundPair(ob.NoAmmoSoundName);
            this.ReloadSound = new MySoundPair(ob.ReloadSoundName);
            this.DeviateShotAngle = MathHelper.ToRadians(ob.DeviateShotAngle);
            this.ReleaseTimeAfterFire = ob.ReleaseTimeAfterFire;
            this.MuzzleFlashLifeSpan = ob.MuzzleFlashLifeSpan;

            this.AmmoMagazinesId = new MyDefinitionId[ob.AmmoMagazines.Length];
            for (int i = 0; i < this.AmmoMagazinesId.Length; i++)
            {
                var ammoMagazine = ob.AmmoMagazines[i];
                this.AmmoMagazinesId[i] = new MyDefinitionId(ammoMagazine.Type, ammoMagazine.Subtype);

                var ammoMagazineDefinition = MyDefinitionManager.Static.GetAmmoMagazineDefinition(this.AmmoMagazinesId[i]);
                MyAmmoType ammoType = MyDefinitionManager.Static.GetAmmoDefinition(ammoMagazineDefinition.AmmoDefinitionId).AmmoType;
                string errorMessage = null;
                switch (ammoType)
                {
                    case MyAmmoType.HighSpeed:
                        MyDebug.AssertDebug(ob.ProjectileAmmoData != null, "No weapon ammo data specified for projectile ammo");
                        if (ob.ProjectileAmmoData != null)
                        {
                            this.WeaponAmmoDatas[(int)MyAmmoType.HighSpeed] = new MyWeaponAmmoData(ob.ProjectileAmmoData);
                        }
                        else
                        {
                            errorMessage  = string.Format(ErrorMessageTemplate, "projectile", "Projectile");
                        }
                        break;
                    case MyAmmoType.Missile:
                         MyDebug.AssertDebug(ob.MissileAmmoData != null, "No weapon ammo data specified for missile ammo");
                        if (ob.MissileAmmoData != null)
                        {
                            this.WeaponAmmoDatas[(int)MyAmmoType.Missile] = new MyWeaponAmmoData(ob.MissileAmmoData);
                        }
                        else
                        {
                            errorMessage = string.Format(ErrorMessageTemplate, "missile", "Missile");
                        }
                        break;
                    default:
                        throw new NotImplementedException();
                }

                if (!string.IsNullOrEmpty(errorMessage))
                {
                    MyDefinitionErrors.Add(Context, errorMessage, TErrorSeverity.Critical);
                }
            }
        }

 public MaterialProperties(MySoundPair soundCue, string particleEffectName, ContactPropertyParticleProperties effectProperties)
 {
     Sound = soundCue;
     ParticleEffectProperties = effectProperties;
     if (particleEffectName != null)
         MyParticlesLibrary.GetParticleEffectsID(
             particleEffectName, out ParticleEffectID);
     else
         ParticleEffectID = -1;
 }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var obProjector = builder as MyObjectBuilder_ProjectorDefinition;
            MyDebug.AssertDebug(obProjector != null, "Initializing camera definition using wrong object builder.!");
	        ResourceSinkGroup = MyStringHash.GetOrCompute(obProjector.ResourceSinkGroup);
            RequiredPowerInput = obProjector.RequiredPowerInput;
            IdleSound = new MySoundPair(obProjector.IdleSound);
        }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);
            var chamberDef = builder as MyObjectBuilder_CryoChamberDefinition;
            OverlayTexture = chamberDef.OverlayTexture;
            IdlePowerConsumption = chamberDef.IdlePowerConsumption;

            OutsideSound = new MySoundPair(chamberDef.OutsideSound);
            InsideSound = new MySoundPair(chamberDef.InsideSound);
        }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var obDefinition = builder as MyObjectBuilder_OxygenGeneratorDefinition;

            this.IceToOxygenRatio = obDefinition.IceToOxygenRatio;
            this.OxygenProductionPerSecond = obDefinition.OxygenProductionPerSecond;

            this.GenerateSound = new MySoundPair(obDefinition.GenerateSound);
            this.IdleSound = new MySoundPair(obDefinition.IdleSound);
        }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_ShipSoundsDefinition;
            MyDebug.AssertDebug(ob != null);

            this.MinWeight = ob.MinWeight;
            this.AllowSmallGrid = ob.AllowSmallGrid;
            this.AllowLargeGrid = ob.AllowLargeGrid;
            this.EnginePitchRangeInSemitones = ob.EnginePitchRangeInSemitones;
            this.EnginePitchRangeInSemitones_h = ob.EnginePitchRangeInSemitones * -0.5f;
            this.EngineTimeToTurnOn = ob.EngineTimeToTurnOn;
            this.EngineTimeToTurnOff = ob.EngineTimeToTurnOff;
            this.WheelsLowerThrusterVolumeBy = ob.WheelsLowerThrusterVolumeBy;
            this.WheelsFullSpeed = ob.WheelsFullSpeed;
            this.ThrusterCompositionMinVolume = ob.ThrusterCompositionMinVolume;
            this.ThrusterCompositionMinVolume_c = ob.ThrusterCompositionMinVolume / (1f - ob.ThrusterCompositionMinVolume);
            this.ThrusterCompositionChangeSpeed = ob.ThrusterCompositionChangeSpeed;
            this.SpeedDownSoundChangeVolumeTo = ob.SpeedDownSoundChangeVolumeTo;
            this.SpeedUpSoundChangeVolumeTo = ob.SpeedUpSoundChangeVolumeTo;
            this.SpeedUpDownChangeSpeed = ob.SpeedUpDownChangeSpeed * MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS;

            foreach (var sound in ob.Sounds)
            {
                if(sound.SoundName.Length == 0)
                    continue;
                MySoundPair soundPair = new MySoundPair(sound.SoundName);
                if (soundPair != MySoundPair.Empty)
                    this.Sounds.Add(sound.SoundType, soundPair);
            }

            List<MyTuple<float, float>> thrusterVolumesTemp = new List<MyTuple<float,float>>();
            foreach (var thrusterVolume in ob.ThrusterVolumes)
            {
                thrusterVolumesTemp.Add(new MyTuple<float, float>(Math.Max(0f, thrusterVolume.Speed), Math.Max(0f, thrusterVolume.Volume)));
            }
            this.ThrusterVolumes = thrusterVolumesTemp.OrderBy(o => o.Item1).ToList();

            List<MyTuple<float, float>> engineVolumesTemp = new List<MyTuple<float, float>>();
            foreach (var engineVolume in ob.EngineVolumes)
            {
                engineVolumesTemp.Add(new MyTuple<float, float>(Math.Max(0f, engineVolume.Speed), Math.Max(0f, engineVolume.Volume)));
            }
            this.EngineVolumes = engineVolumesTemp.OrderBy(o => o.Item1).ToList();

            List<MyTuple<float, float>> wheelsVolumesTemp = new List<MyTuple<float, float>>();
            foreach (var wheelsVolume in ob.WheelsVolumes)
            {
                wheelsVolumesTemp.Add(new MyTuple<float, float>(Math.Max(0f, wheelsVolume.Speed), Math.Max(0f, wheelsVolume.Volume)));
            }
            this.WheelsVolumes = wheelsVolumesTemp.OrderBy(o => o.Item1).ToList();
        }

 public EffectSoundEmitter(uint id, Vector3 position, MySoundPair sound)
 {
     ParticleSoundId = id;
     Updated = true;
     Emitter = new MyEntity3DSoundEmitter(null);
     Emitter.SetPosition(position);
     Emitter.PlaySound(sound);
     if (Emitter.Sound != null)
         OriginalVolume = Emitter.Sound.Volume;
     else
         OriginalVolume = 1f;
     Emitter.Update();
 }

 protected override void Init(MyObjectBuilder_DefinitionBase builder)
 {
     var ob = (MyObjectBuilder_RopeDefinition)builder;
     this.EnableRayCastRelease = ob.EnableRayCastRelease;
     this.IsDefaultCreativeRope = ob.IsDefaultCreativeRope;
     this.ColorMetalTexture = ob.ColorMetalTexture;
     this.NormalGlossTexture = ob.NormalGlossTexture;
     this.AddMapsTexture = ob.AddMapsTexture;
     if (!string.IsNullOrEmpty(ob.AttachSound)) this.AttachSound = new MySoundPair(ob.AttachSound);
     if (!string.IsNullOrEmpty(ob.DetachSound)) this.DetachSound = new MySoundPair(ob.DetachSound);
     if (!string.IsNullOrEmpty(ob.WindingSound)) this.WindingSound = new MySoundPair(ob.WindingSound);
     base.Init(builder);
 }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var airVent = builder as MyObjectBuilder_AirVentDefinition;
            MyDebug.AssertDebug(airVent != null, "Initializing air vent definition using wrong object builder.");
            
            StandbyPowerConsumption = airVent.StandbyPowerConsumption;
            OperationalPowerConsumption = airVent.OperationalPowerConsumption;
            VentilationCapacityPerSecond = airVent.VentilationCapacityPerSecond;

            PressurizeSound = new MySoundPair(airVent.PressurizeSound);
            DepressurizeSound = new MySoundPair(airVent.DepressurizeSound);
            IdleSound = new MySoundPair(airVent.IdleSound);
        }

 public CollisionProperty(string soundCue, string particleEffectName, List<AlternativeImpactSounds> impactsounds)
 {
     Sound = new MySoundPair(soundCue);
     ParticleEffect = particleEffectName;
     if (impactsounds == null || impactsounds.Count == 0)
         ImpactSoundCues = null;
     else
     {
         ImpactSoundCues = new List<ImpactSounds>();
         foreach (var impactSound in impactsounds)
         {
             ImpactSoundCues.Add(new ImpactSounds(impactSound.mass, impactSound.soundCue, impactSound.minVelocity, impactSound.maxVolumeVelocity));
         }
     }
 }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var obDefinition = builder as MyObjectBuilder_OxygenGeneratorDefinition;

			IceConsumptionPerSecond = obDefinition.IceConsumptionPerSecond;

            GenerateSound = new MySoundPair(obDefinition.GenerateSound);
            IdleSound = new MySoundPair(obDefinition.IdleSound);

			ResourceSourceGroup = MyStringHash.GetOrCompute(obDefinition.ResourceSourceGroup);

	        ProducedGases = null;
	        if (obDefinition.ProducedGases != null)
	        {
				ProducedGases = new List<MyGasGeneratorResourceInfo>(obDefinition.ProducedGases.Count);
		        foreach(var producedGasInfo in obDefinition.ProducedGases)
					ProducedGases.Add(producedGasInfo);
	        }
        }

 public EffectSoundEmitter(uint id, Vector3 position, MySoundPair sound)
 {
     ParticleSoundId = id;
     Updated = true;
     MyEntity entity = null;
     if (MyFakes.ENABLE_NEW_SOUNDS && MySession.Static.Settings.RealisticSound)//snap emitter to closest block - used for realistic sounds
     {
         List<MyEntity> m_detectedObjects = new List<MyEntity>();
         BoundingSphereD effectSphere = new BoundingSphereD(MySession.Static.LocalCharacter != null ? MySession.Static.LocalCharacter.PositionComp.GetPosition() : MySector.MainCamera.Position, 2f);
         MyGamePruningStructure.GetAllEntitiesInSphere(ref effectSphere, m_detectedObjects);
         float distBest = float.MaxValue;
         float dist;
         for (int i = 0; i < m_detectedObjects.Count; i++)
         {
             MyCubeBlock block = m_detectedObjects[i] as MyCubeBlock;
             if (block != null)
             {
                 dist = Vector3.DistanceSquared(MySession.Static.LocalCharacter.PositionComp.GetPosition(), block.PositionComp.GetPosition());
                 if (dist < distBest)
                 {
                     dist = distBest;
                     entity = block;
                 }
             }
         }
         m_detectedObjects.Clear();
     }
     Emitter = new MyEntity3DSoundEmitter(entity);
     Emitter.SetPosition(position);
     if (sound == null)
         sound = MySoundPair.Empty;
     Emitter.PlaySound(sound);
     if (Emitter.Sound != null)
         OriginalVolume = Emitter.Sound.Volume;
     else
         OriginalVolume = 1f;
     Emitter.Update();
     SoundPair = sound;
 }

        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var materialBuilder = builder as MyObjectBuilder_PhysicalMaterialDefinition;
            if (materialBuilder != null)
            {
                //MyDebug.AssertDebug(materialBuilder != null, "Initializing physical material definition using wrong object builder.");
                Density = materialBuilder.Density;
                HorisontalTransmissionMultiplier = materialBuilder.HorisontalTransmissionMultiplier;
                HorisontalFragility = materialBuilder.HorisontalFragility;
                SupportMultiplier = materialBuilder.SupportMultiplier;
                CollisionMultiplier = materialBuilder.CollisionMultiplier;
                DamageDecal = materialBuilder.DamageDecal;
            }
            var soundBuilder = builder as MyObjectBuilder_MaterialSoundsDefinition;
            if(soundBuilder != null)
            {
                InheritSoundsFrom = MyStringHash.GetOrCompute(soundBuilder.InheritFrom);
                

                foreach(var sound in soundBuilder.ContactSounds)
                {
                    var type = MyStringId.GetOrCompute(sound.Type);
                    if (!CollisionSounds.ContainsKey(type))
                        CollisionSounds[type] = new Dictionary<MyStringHash, MySoundPair>(MyStringHash.Comparer);
                    var material = MyStringHash.GetOrCompute(sound.Material);

                    Debug.Assert(!CollisionSounds[type].ContainsKey(material), "Overwriting material sound!");

                    CollisionSounds[type][material] = new MySoundPair(sound.Cue);
                }

                foreach(var sound in soundBuilder.GeneralSounds)
                {
                    GeneralSounds[MyStringId.GetOrCompute(sound.Type)] = new MySoundPair(sound.Cue);
                }
            }
        }   

        public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
        {
            base.Init(builder, cubeGrid);

            //m_subpartsSize = 0.5f * (0.5f * SlimBlock.CubeGrid.GridSize - 0.3f);
            var doorDefinition = BlockDefinition as MyDoorDefinition;
	        MyStringHash resourceSinkGroup;
            if (doorDefinition != null)
            {
                MaxOpen = doorDefinition.MaxOpen;
                m_openSound = new MySoundPair(doorDefinition.OpenSound);
                m_closeSound = new MySoundPair(doorDefinition.CloseSound);
				resourceSinkGroup = MyStringHash.GetOrCompute(doorDefinition.ResourceSinkGroup);
            }
            else
            {
                MaxOpen = 1.2f;
                m_openSound = new MySoundPair("BlockDoorSmallOpen");
                m_closeSound = new MySoundPair("BlockDoorSmallClose");
				resourceSinkGroup = MyStringHash.GetOrCompute("Doors");
            }

            var ob = (MyObjectBuilder_Door)builder;
            m_open = ob.State;
            m_currOpening = ob.Opening;

			var sinkComp = new MyResourceSinkComponent();
            sinkComp.Init(
				resourceSinkGroup, 
                MyEnergyConstants.MAX_REQUIRED_POWER_DOOR,
				() => (Enabled && IsFunctional) ? sinkComp.MaxRequiredInput : 0f);
			sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged;
			sinkComp.Update();

	        ResourceSink = sinkComp;
			if (!Enabled || !ResourceSink.IsPowered)
                UpdateSlidingDoorsPosition(true);


            OnStateChange();

            if (m_open)
            {
                // required when reinitializing a door after the armor beneath it is destroyed
                if (Open && (m_currOpening == MaxOpen))
                    UpdateSlidingDoorsPosition(true);
            }

            SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
        }

        public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
        {
            var medicalRoomDefinition = BlockDefinition as MyMedicalRoomDefinition;
            MyStringHash resourceSinkGroup;
            if (medicalRoomDefinition != null)
            {
                m_idleSound = new MySoundPair(medicalRoomDefinition.IdleSound);
                m_progressSound = new MySoundPair(medicalRoomDefinition.ProgressSound);
                resourceSinkGroup = MyStringHash.GetOrCompute(medicalRoomDefinition.ResourceSinkGroup);
            }
            else
            {
                m_idleSound = new MySoundPair("BlockMedical");
                m_progressSound = new MySoundPair("BlockMedicalProgress");
                resourceSinkGroup = MyStringHash.GetOrCompute("Utility");
            }

            SinkComp = new MyResourceSinkComponent();
            SinkComp.Init(
                resourceSinkGroup,
                MyEnergyConstants.MAX_REQUIRED_POWER_MEDICAL_ROOM,
                () => (Enabled && IsFunctional) ? SinkComp.MaxRequiredInput : 0f);
            SinkComp.IsPoweredChanged += Receiver_IsPoweredChanged;

            base.Init(objectBuilder, cubeGrid);
	         
            m_rechargeSocket = new MyRechargeSocket();

            NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME;

            SteamUserId = (objectBuilder as MyObjectBuilder_MedicalRoom).SteamUserId;

            if (SteamUserId != 0) //backward compatibility
            {
                MyPlayer controller = Sync.Players.GetPlayerById(new MyPlayer.PlayerId(SteamUserId));
                if (controller != null)
                {
                    IDModule.Owner = controller.Identity.IdentityId;
                    IDModule.ShareMode = MyOwnershipShareModeEnum.Faction;
                }
            }
            SteamUserId = 0;

            m_takeSpawneeOwnership = (objectBuilder as MyObjectBuilder_MedicalRoom).TakeOwnership;
            m_setFactionToSpawnee = (objectBuilder as MyObjectBuilder_MedicalRoom).SetFaction;
       
            SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;

            InitializeConveyorEndpoint();
            SinkComp.Update();
			
            AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(SinkComp, this));

            if (this.CubeGrid.CreatePhysics)
                Components.Add<MyRespawnComponent>(new MyRespawnComponent());

            m_healingAllowed                = medicalRoomDefinition.HealingAllowed;
            m_refuelAllowed                 = medicalRoomDefinition.RefuelAllowed;
            m_suitChangeAllowed             = medicalRoomDefinition.SuitChangeAllowed;
            m_customWardrobesEnabled        = medicalRoomDefinition.CustomWardrobesEnabled;
            m_forceSuitChangeOnRespawn      = medicalRoomDefinition.ForceSuitChangeOnRespawn;
            m_customWardrobeNames           = medicalRoomDefinition.CustomWardrobeNames;
            m_respawnSuitName               = medicalRoomDefinition.RespawnSuitName;
            m_spawnWithoutOxygenEnabled     = medicalRoomDefinition.SpawnWithoutOxygenEnabled;
            RespawnAllowed                  = medicalRoomDefinition.RespawnAllowed;
        }

 static MyTrees()
 {
     m_soundTreeBreak = new MySoundPair("ImpTreeBreak");
 }