private class Sound
        {
            private struct SoundInstance
            {
                public SoundEffectInstance SoundEffectInstance;
                public bool Activated;
                public SoundInstance(SoundEffectInstance soundEffect, bool played)
                {
                    SoundEffectInstance = soundEffect;
                    Activated = played;
                }
            }
            /// <summary>
            /// Количество существующих копий данного звука.
            /// </summary>
            public int count;
            /// <summary>
            /// Звук для создания его независимых копий
            /// </summary>
            private SoundEffect effect;
            /// <summary>
            /// Массив с независимыми копиями
            /// </summary>
            private SoundInstance[] effect_copies;
 
            /// <summary>
            /// Стек с доступными номерами звуков.
            /// </summary>
            private Stack<int> unused_sounds_stack;
            /// <summary>
            /// Тип звука. Используется enum, чтобы при поиске избегать пересоздания строк.
            /// </summary>
            public SoundType Type;
            /// <summary>
            /// Максимальное число копий данного звука - выбрано с учетом того, 
            /// что максимальное число одновременно проигрываемых звуков на Windows Phone - 64.
            /// </summary>
            private int MaxSoundCopies = 16;
            /// <summary>
            /// Инициализация
            /// </summary>
            /// <param name="_type">Тип звука</param>
            /// <param name="_effect">Ссылка на SoundEffect</param>
            public Sound(SoundType _type, SoundEffect _effect)
            {
                Initialize(_type, _effect, 16);
            }
 
            /// <summary>
            /// Инициализация c возможностью задать максимальное число копий данного звука 
            /// </summary>
            /// <param name="_type">Тип звука</param>
            /// <param name="_effect">Ссылка на SoundEffect</param>
            /// <param name="maxSoundCopies">Максимальное число копий данного звука</param>
            public Sound(SoundType _type, SoundEffect _effect, int maxSoundCopies)
            {
                Initialize(_type, _effect, maxSoundCopies);
            }
 
            private void Initialize(SoundType _type, SoundEffect _effect, int maxSoundCopies)
            {
                Type = _type;
                effect = _effect;
                effect_copies = new SoundInstance[MaxSoundCopies];
                unused_sounds_stack = new Stack<int>(MaxSoundCopies);
                MaxSoundCopies = maxSoundCopies;
                for (int i = 0; i < MaxSoundCopies; i++)
                {
                    effect_copies[i].SoundEffectInstance = effect.CreateInstance();
                    unused_sounds_stack.Push(i);
                }
            }
 
            /// <summary>
            /// Проигрывание звука.
            /// </summary>
            /// <param name="volume">Громкость</param>
            /// <param name="looped">Повторять звук</param>
            /// <returns>Возвращает ссылку на копию SoundEffectInstance, 
            /// чтобы можно было остановить именно её а не все копии данного звука.</returns>
            public SoundEffectInstance Play(float volume, bool looped)
            {
                if (count < MaxSoundCopies)
                {
                    int unused_sound_num = unused_sounds_stack.Pop();
                    SoundEffectInstance instance = effect_copies[unused_sound_num].SoundEffectInstance;
                    effect_copies[unused_sound_num].Activated = true;
                    if (instance.IsLooped != looped)
                    {
                        instance = effect_copies[unused_sound_num].SoundEffectInstance = effect.CreateInstance();
                        instance.IsLooped = looped;
                    }
                    instance.Volume = volume;
                    instance.Play();
                    count++;
                    return instance;
                }
                return null;
            }
 
            /// <summary>
            /// Остановка всех копий данного звука.
            /// </summary>
            /// <param name="only_looped">Остановка только зацикленных звуков</param>
            public void Stop(bool only_looped)
            {
                if (only_looped)
                {
                    //unused_sounds_stack.Clear();
                    for (int i = 0; i < count; i++)
                    {
                        if (effect_copies[i].SoundEffectInstance.IsLooped)
                        {
                            effect_copies[i].SoundEffectInstance.Stop();
                            effect_copies[i].Activated = false;
                            unused_sounds_stack.Push(i);
                            count--;
                        }
                    }
                }
                else
                {
                    unused_sounds_stack.Clear();
                    for (int i = 0; i < count; i++)
                    {
                        effect_copies[i].SoundEffectInstance.Stop();
                        effect_copies[i].Activated = false;
                        unused_sounds_stack.Push(i);
                    }
                    count = 0;
                }
            }
 
            public void Update(GameTime gameTime)
            {
                for (int i = 0; i < MaxSoundCopies; i++)
                {
                    if (effect_copies[i].SoundEffectInstance.State == SoundState.Stopped && 
                        effect_copies[i].Activated == true)//Если звук проигрался убираем его из списка
                    {
                        effect_copies[i].Activated = false;
                        unused_sounds_stack.Push(i);
                        count--;
                    }
                }
            }
        }
 
Добавлено за 0.032 секунд, используя GeSHi 1.0.8.2

 
///Файл Player.cs
Stopwatch st = new Stopwatch();
public void Fire()
        {
 
            st.Start();
            if (!Unconrolled && canFire && !EmptyWeaponColors)
            {
 
                if (!Destroyed && !bMoving)
                {
                    canFire = false;
                    map.CreateWeaponFire(WeaponType.LaserBeam, this.FirePosition, CurrentEnergyColor);
                }
 
                if (CurrentEnergyIndex >= 3)
                {
                    WeaponsColors = emptyColors;
                    EmptyWeaponColors = true;
                    CurrentEnergyIndex = 0;
                }
                else
                {
                    WeaponsColors[CurrentEnergyIndex] = emptyColor;
                    CurrentEnergyIndex++;
                }
            }
            st.Stop();
            Debug.WriteLine(st.Elapsed.TotalMilliseconds);
            st.Reset();
        }
 
Добавлено за 0.010 секунд, используя GeSHi 1.0.8.2

//Файл MapBase.cs
 
        //Вызов из Player.cs Fire()
        public void CreateWeaponFire(WeaponType weaponType, Vector2 position, Color playerColor)
        {
            CreateWeaponFire(weaponType, position, new Vector2(0, -10), playerColor);
        }
 
        //Вызов из метода выше
        public void CreateWeaponFire(WeaponType weaponType, Vector2 position, 
                                                   Vector2 direction, Color playerColor)
        {
            CreateWeaponFire(weaponType, position, direction, playerColor, false); 
        }
 
        //Вызов из метода выше
        public void CreateWeaponFire(WeaponType weaponType, Vector2 position,
                                                   Vector2 direction, Color color, bool silence)
        {
            switch (weaponType)
            {
                case WeaponType.LaserBeam: 
                    Weapons.Add(new WeaponLaserBeam(color, position, direction, 
                    100, 100, ParticlesWeaponsController));
                    if (!silence)
                        SoundManager.Play(SoundType.Laser_shot_1, SettingsManager.SoundVolume * 0.4f);
                    break;
                 //... Другие виды оружия
            }
        }
Добавлено за 0.010 секунд, используя GeSHi 1.0.8.2

//WeaponBase.cs
public WeaponBase(WeaponType weaponType, Vector2 position, int damage, 
                             Vector2 moveVector, SpectrumColor color, int maxEnergy)
        {
            WeaponType = weaponType;
            Position = position;
            Damage = damage;
            move = moveVector;
            SpecColor = color;
            Alive = true;
            Energy = maxEnergy;
            firstTime = true;
            Row = -1;
            Col = -1;
        }
Добавлено за 0.007 секунд, используя GeSHi 1.0.8.2

//WeaponLaserBeam.cs
ParticleController particles;
        private bool exploded;
        public WeaponLaserBeam(Color color, Vector2 position, Vector2 moveVector, 
                                             int damage, int maxEnergy, ParticleController pcontroller)
            : base(WeaponType.LaserBeam, position, damage, moveVector, color, maxEnergy)
        {
            particles = pcontroller;
        }
 
        public override void Update(GameTime gameTime)
        {
            if (Energy <= 0 && particles.particles.Count == 0)
                Alive = false;
            Position += move;
            Row = (int)Position.Y / 48;
            Col = (int)Position.X / 48;
            Vector2 v2Center = new Vector2(Position.X, Position.Y + 3);
            if (!Collided)
                particles.LaserTrail(v2Center, SpecColor);
            else
            {
                if (!exploded)
                {
                    exploded = true;
                    particles.EngineExplode(CollisionPoint, SpecColor, 0.8f);
                }
 
                if (PlayerCollided && exploded)
                {
                    exploded = false;
                    PlayerCollided = false;
                    particles.EngineExplode(CollisionPoint, SpecColor, 0.3f);
                }
 
                if(Energy > 0)
                particles.EngineRocketReverse(v2Center, SpecColor);
            }
            //particles.Update(gameTime);
 
        }
Добавлено за 0.018 секунд, используя GeSHi 1.0.8.2

//ParticleController.cs
        public void LaserTrail(Vector2 position, Color Color) // функция, которая будет генерировать частицы
        {
            for (int a = 0; a < 2; a++) // создаем 2 частицы дыма для трейла
            {
                Vector2 velocity_s = AngleToV2((float)(Math.PI * 2d * RandomManager.NextDouble()), 0.6f);
                float angle_s = 0;
                float angleVel_s = 0;
                Vector4 color_s = Color.ToVector4();
                float size_s = 1f;
                int ttl_s = 10;
                float sizeVel_s = 0;
                float alphaVel_s = -0.1f;
                GenerateNewParticle(ContentStorage.particles_weapons_spark, position, 
                velocity_s, angle_s, angleVel_s, color_s, size_s, ttl_s, sizeVel_s, alphaVel_s);
            }
 
            Vector2 velocity = AngleToV2((float)(Math.PI * 2d * RandomManager.NextDouble()), .2f);
            Vector4 color = Color.ToVector4() * 0.7f;
            float size = 1f;
            int ttl = 10;
            float sizeVel = -.01f;
            float alphaVel = .01f;
 
            GenerateNewParticle(ContentStorage.particles_weapons_smoke, position, 
            velocity, 0, 0, color, size, ttl, sizeVel, alphaVel);
 
            velocity = Vector2.Zero;
            color = Color.ToVector4();
            size = 0.1f + 1.8f * (float)RandomManager.NextDouble();
            ttl = 5;
            sizeVel = -.05f;
            alphaVel = .01f;
            GenerateNewParticle(ContentStorage.particles_weapons_spark, position, 
             velocity, 0, 0, color, size, ttl, sizeVel, alphaVel);
 
        }
private Particle GenerateNewParticle(Texture2D texture, Vector2 position, Vector2 velocity,
            float angle, float angularVelocity, 
            Vector4 color, float size, int ttl, float sizeVel, float alphaVel) // генерация новой частички
        {
            Particle particle = new Particle(texture, position, velocity, angle, 
            angularVelocity, color, size, ttl, sizeVel, alphaVel, false, 1);
            particles.Add(particle);
            return particle;
        }
Добавлено за 0.020 секунд, используя GeSHi 1.0.8.2