public static Sustainer AggregateOrSpawnSustainerFor(ISizeReporter reporter, SoundDef def, SoundInfo info)
        {
            Sustainer sustainer = null;

            foreach (Sustainer sustainer2 in Find.SoundRoot.sustainerManager.AllSustainers)
            {
                if (sustainer2.def == def && sustainer2.info.Maker.Map == info.Maker.Map && sustainer2.info.Maker.Cell.InHorDistOf(info.Maker.Cell, SustainerAggregatorUtility.AggregateRadius))
                {
                    sustainer = sustainer2;
                    break;
                }
            }
            if (sustainer == null)
            {
                sustainer = def.TrySpawnSustainer(info);
            }
            else
            {
                sustainer.Maintain();
            }
            if (sustainer.externalParams.sizeAggregator == null)
            {
                sustainer.externalParams.sizeAggregator = new SoundSizeAggregator();
            }
            sustainer.externalParams.sizeAggregator.RegisterReporter(reporter);
            return(sustainer);
        }
        public static bool AggregateOrSpawnSustainerFor(ref Sustainer __result, ISizeReporter reporter, SoundDef def, SoundInfo info)
        {
            Sustainer sustainer = null;
            Sustainer allSustainer;
            for (int i = 0; i < Find.SoundRoot.sustainerManager.AllSustainers.Count; i++)
            {
                try
                {
                    allSustainer = Find.SoundRoot.sustainerManager.AllSustainers[i];
                } catch (ArgumentOutOfRangeException) { break; }
                if (allSustainer != null && allSustainer.def == def && allSustainer.info.Maker.Map == info.Maker.Map && allSustainer.info.Maker.Cell.InHorDistOf(info.Maker.Cell, AggregateRadius))
                {
                    sustainer = allSustainer;
                    break;
                }
            }

            if (sustainer == null)
            {
                sustainer = def.TrySpawnSustainer(info);
            }
            else
            {
                sustainer.Maintain();
            }

            if (sustainer.externalParams.sizeAggregator == null)
            {
                sustainer.externalParams.sizeAggregator = new SoundSizeAggregator();
            }

            sustainer.externalParams.sizeAggregator.RegisterReporter(reporter);
            __result = sustainer;
            return false;
        }
 public static bool RegisterReporter(SoundSizeAggregator __instance, ISizeReporter newRep)
 {
     lock (reporters(__instance))
     {
         reporters(__instance).Add(newRep);
     }
     return(false);
 }
 public static bool RegisterReporter(SoundSizeAggregator __instance, ISizeReporter newRep)
 {
     lock (__instance.reporters)             //added lock
     {
         __instance.reporters.Add(newRep);
     }
     return(false);
 }
Esempio n. 5
0
 public static bool RemoveReporter(SoundSizeAggregator __instance, ISizeReporter oldRep)
 {
     lock (reporters(__instance))
     {
         reporters(__instance).Remove(oldRep);
     }
     return(false);
 }
 public static bool RemoveReporter(SoundSizeAggregator __instance, ISizeReporter oldRep)
 {
     lock (reporters(__instance))
     {
         List <ISizeReporter> newReporters = new List <ISizeReporter>(reporters(__instance));
         newReporters.Remove(oldRep);
         reporters(__instance) = newReporters;
     }
     return(false);
 }
 public static bool RemoveReporter(SoundSizeAggregator __instance, ISizeReporter oldRep)
 {
     lock (__instance.reporters)
     {
         List <ISizeReporter> newReporters = new List <ISizeReporter>(__instance.reporters); //safe copy remove
         newReporters.Remove(oldRep);
         __instance.reporters = newReporters;
     }
     return(false);
 }
        public static bool get_AggregateSize(SoundSizeAggregator __instance, ref float __result)
        {
            if (reporters(__instance).Count == 0)
            {
                __result = testSize(__instance);
                return(false);
            }

            float num = 0f;

            for (int i = 0; i < reporters(__instance).Count; i++)
            {
                ISizeReporter reporter = reporters(__instance)[i];
                if (reporter != null)
                {
                    num += reporter.CurrentSize();
                }
            }

            __result = num;
            return(false);
        }
Esempio n. 9
0
 public void RemoveReporter(ISizeReporter oldRep)
 {
     reporters.Remove(oldRep);
 }
Esempio n. 10
0
 public void RegisterReporter(ISizeReporter newRep)
 {
     reporters.Add(newRep);
 }