void Awake(){
		gene = geneIni;
		biomatter = biomatterIni;
		newSpawnCostGene = newSpawnGene;
		newSpawnCostBio = newSpawnBio;
		pool = GameObject.Find ("Pool").GetComponent<Pool> ();
	}

	void Awake() {
		if (GameObject.FindWithTag("PoolHolder")) {
			masterPoolHolder = GameObject.FindWithTag("PoolHolder");
		} else {
			masterPoolHolder = new GameObject("Pool Holder");
			masterPoolHolder.tag = "PoolHolder";
		}
		if (masterPool == null) {
			masterPool = new List<Pool>();
		}
		Pool existingPool = null;
		foreach (var p in masterPool) {
			if (p.prefab == prefab) existingPool = p;
		}
		if (existingPool == null) {
			pool = new Pool();
			pool.prefab = prefab;
			if (parentGO == null) {
				pool.holder = new GameObject(string.Format("{0} Holder", prefab.name));
				pool.holder.transform.parent = masterPoolHolder.transform;
			} else {
				pool.holder = parentGO;
			}
			if (instantiateOnAwake) {
				for (int i = 0; i < poolAmount; i++) {
					AddPoolObject();
				}
			}
			masterPool.Add(pool);
		} else {
			pool = existingPool;
		}
	}

 public void SetPool(Pool pool)
 {
     _pool = pool;
     _pool.GetGroup(Matcher.SettingsModel).OnEntityUpdated += update;
     _group = pool.GetGroup(Matcher.DifficultyController);
     _models = pool.GetGroup(Matcher.DifficultyModel);
 }

 public void SetPool(Pool pool)
 {
     _pool = pool;
     _camera = _pool.GetGroup(Matcher.Camera);
     _time = _pool.GetGroup(Matcher.Time);
     _group = pool.GetGroup(Matcher.AllOf(Matcher.Path, Matcher.GameObject, Matcher.Velocity, Matcher.VelocityLimit, Matcher.Position));
 }

 void Start()
 {
     _pool = new Pool(ComponentIds.TotalComponents);
     _systems = createSystems();
     _systems.Start();
     _pool.CreateEntity().AddMyString("");
 }

	void Start () {
		//Inicializamos el path para evitar errores;
		initPos = new Vector3(0,0,100000);
		//Buscamos la pool para solicitar los creeps;
		pool = GameObject.Find ("Pool").GetComponent<Pool> ();
		//Iniciamos la solicitud de creeps basicos;
		invokeGene [0] = true;
		invokeGene [1] = false;
		Invoke("Create",1f/spawnRate);
		//Iniciamos la solicitud de creeps de tier;
		//Invoke("CreateTier",spawnRateTier);
		//Texto para ver el numero de creeps;
		textNumberCreeps = GameObject.Find ("CreepsText/Number").GetComponent<UITest> ();
		numberCreeps = 0;
		pathfinder = GameObject.Find("GameManager/PathFinder").GetComponent<PathFinding>();
		geneSpeed = 0;
		/***************************
	 	* SOLO PARA LAS PRUEBAS DE LA BARRA DE GENERACION*/
		spritesGene [0] = transform.FindChild ("ProductionBar/Prod_0").GetComponent<SpriteRenderer> ();
		spritesGene [1] = transform.FindChild ("ProductionBar/Prod_1").GetComponent<SpriteRenderer> ();
		spritesGene [2] = transform.FindChild ("ProductionBar/Prod_2").GetComponent<SpriteRenderer> ();
		spritesGene [3] = transform.FindChild ("ProductionBar/Prod_3").GetComponent<SpriteRenderer> ();
		spritesGene [4] = transform.FindChild ("ProductionBar/Prod_4").GetComponent<SpriteRenderer> ();
		/*****************************/
		touchManager = GameObject.Find ("GameManager/TouchManager").GetComponent<TouchManager> ();
		tier = 0;
		subType = -1;
		numBioPools = 0;
	}

  public void OnEnable()
  {
    m_Pool = PoolManager.CreatePool(PrefabPaths.CAPSULE, poolSize: 0, parent: transform);


    StartCoroutine(TestQueueInit());
  }

 public void Test_DisposeContainedResources()
 {
     var disposable = new Disposable();
     var pool = new Pool<Disposable>(() => disposable, AccessStrategy.LIFO, LoadingStrategy.Eager, 1);
     pool.Dispose();
     Assert.True(disposable.Disposed);
 }

        public void Test_Dispose_4()
        {
            Disposable disposable;
            PoolResourceHolder<Disposable> poolResourceHolder;
            var pool = new Pool<Disposable>(() => new Disposable(), AccessStrategy.LIFO, LoadingStrategy.Eager, 1);
            pool.Dispose();

            Assert.Throws<ObjectDisposedException>(() => pool.Acquire());
            Assert.Throws<ObjectDisposedException>(() => pool.AcquireHolder());
            Assert.Throws<ObjectDisposedException>(() => pool.TryAcquire(TimeSpan.FromDays(1), out disposable));
            Assert.Throws<ObjectDisposedException>(() => pool.TryAcquireHolder(TimeSpan.FromDays(1), out poolResourceHolder));
            Assert.Throws<ObjectDisposedException>(() => pool.TryAcquireImmediately(out disposable));
            Assert.Throws<ObjectDisposedException>(() => pool.TryAcquireHolderImmediately(out poolResourceHolder));

            // Асинхронные методы.
            try
            {
                pool.AcquireAsync().Wait();
                Assert.Fail("Must throw exception.");
            }
            catch (AggregateException error)
            {
                Assert.True(error.InnerExceptions.Single() is ObjectDisposedException);
            }
            try
            {
                pool.AcquireHolderAsync().Wait();
                Assert.Fail("Must throw exception.");
            }
            catch (AggregateException error)
            {
                Assert.True(error.InnerExceptions.Single() is ObjectDisposedException);
            }
        }

	static IEnumerable LeaderboardCoroutine(Pool pool, Entity e, float startTime)
	{
		var audioSource = GameObject.Find("MusicSource").GetComponent<AudioSource>();
		
		for (int i = 3; i >= 0; --i)
		{
			audioSource.volume = 0.25f * (i / 3.0f);
			yield return WaitMs(e, 200);
		}
		
		audioSource.Stop();
		if(pool.hasLowestScoreLeaderboard && pool.lowestScoreLeaderboard.value <= pool.score.value)
		{
			audioSource.clip = (AudioClip)Resources.Load("Music/GameOverHighScore");
		}
		else
		{
			audioSource.clip = (AudioClip)Resources.Load("Music/GameOver");
		}
		audioSource.volume = 0.25f;
		audioSource.loop = false;
		audioSource.Play();
		
		yield return WaitMs(e, 1200);
		
		e.AddLeaderboard("");
		e.AddResource("Leaderboard");
	}

 void Start() {
     _pool = new Pool(ComponentIds.TotalComponents);
     new PoolObserver(_pool, ComponentIds.componentNames, ComponentIds.componentTypes, "Systems Pool");
     _systems = createSystems();
     _systems.Initialize();
     _pool.CreateEntity().AddMyString("");
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pool">May not be null. HA must be turned off on the pool.</param>
        public EditVmHaPrioritiesDialog(Pool pool)
        {
            if (pool == null)
                throw new ArgumentNullException("pool");
            if (!pool.ha_enabled)
                throw new ArgumentException("You may only show the EditVmHaPrioritiesDialog for pools that already have HA turned on");

            this.pool = pool;
            InitializeComponent();
            Text += string.Format(" - '{0}'", pool.Name.Ellipsise(30));
            assignPriorities.StatusChanged += assignPriorities_StatusChanged;

            pool.PropertyChanged += pool_PropertyChanged;
            originalNtol = pool.ha_host_failures_to_tolerate;

            if (pool.ha_statefiles.Length != 1)
            {
                log.ErrorFormat("Cannot show dialog: pool {0} has {1} statefiles, but this dialog can only handle exactly 1. Closing dialog.",
                    pool.Name, pool.ha_statefiles.Length);
                this.Close();
                return;
            }

            XenRef<VDI> vdiRef = new XenRef<VDI>(pool.ha_statefiles[0]);
            VDI vdi = pool.Connection.Resolve(vdiRef);
            if (vdi == null)
            {
                log.Error("Could not resolve HA statefile reference. Closing dialog.");
                this.Close();
                return;
            }

            pictureBoxWarningIcon.Image = SystemIcons.Warning.ToBitmap();
            Rebuild();
        }

 public MissingSRProblem(Check check, Pool pool, SR sr, Dictionary<string, string> device_config)
     : base(check)
 {
     this.pool = pool;
     this.sr = sr;
     this.device_config = device_config;
 }

 public PerfmonOptionsDefinitionAction(IXenConnection connection, PerfmonOptionsDefinition perfmonOptions)
     : base(connection, Messages.ACTION_CHANGE_EMAIL_OPTIONS)
 {
     this.perfmonOptions = perfmonOptions;
     pool = Helpers.GetPoolOfOne(connection);
     this.Description = string.Format(Messages.ACTION_CHANGING_EMAIL_OPTIONS_FOR, pool);
 }

 public BonusesView(Pool pool, IViewService viewService, IBonusService bonusService)
     : base("EditorView/Bonus/BonusesView")
 {
     this.pool = pool;
     this.viewService = viewService;
     this.bonusService = bonusService;
 }

        public static void InitializeTerrainNodeDelegates(GraphicsDevice graphicsDevice)
        {
            TerrainNodeDelegates.graphicsDevice = graphicsDevice;

              terrainNodeVertexBufferPool = new Pool<TerrainNodeVertexBuffer>(512, t => t.Active)
              {
            Initialize = t =>
            {
              // TODO : don't hard code border usage
              t.Initialize(graphicsDevice, (Constants.PatchWidth + 2) * (Constants.PatchHeight + 2));
            },

            Deinitialize = t =>
              {
              }
              };

              // pre-allocate vertex buffers
              object[] items = new object[512];

              for (int i = 0; i < 512; i++)
            items[i] = (object)terrainNodeVertexBufferPool.New();

              // release items
              for (int i = 0; i < 50; i++)
            ((TerrainNodeVertexBuffer)items[i]).Finished();
        }

        public WlbOptimizePoolAction(Pool pool, Dictionary<VM, WlbOptimizationRecommendation> vmOptLst, string optId)
            : base(pool.Connection, string.Format(Messages.WLB_OPTIMIZING_POOL, Helpers.GetName(pool).Ellipsise(50)))
        {
            if (pool == null)
                throw new ArgumentNullException("pool");
            if (vmOptLst == null)
                throw new ArgumentNullException("vmOptLst");

            this.Pool = pool;
            this.vmOptList = vmOptLst;
            this.optId = optId;

            #region RBAC Dependencies
            // HA adjustments
            ApiMethodsToRoleCheck.Add("pool.sync_database");
            ApiMethodsToRoleCheck.Add("pool.set_ha_host_failures_to_tolerate");
            ApiMethodsToRoleCheck.Add("vm.set_ha_restart_priority");
            ApiMethodsToRoleCheck.Add("vm.set_ha_always_run");

            ApiMethodsToRoleCheck.Add("vm.assert_can_boot_here");
            ApiMethodsToRoleCheck.Add("vm.assert_agile");
            ApiMethodsToRoleCheck.AddRange(Role.CommonTaskApiList);
            ApiMethodsToRoleCheck.AddRange(Role.CommonSessionApiList);
            #endregion
        }

 public CallHomeEnrollNowDialog(Pool pool)
 {
     this.pool = pool;
     InitializeComponent();
     InitializeControls();
     UpdateButtons();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SelectedItem"/> class.
 /// </summary>
 /// <param name="xenObject">The xen object that is selected.</param>
 /// <param name="connection">The connection of the xen object.</param>
 /// <param name="hostAncestor">The host ancestor of the xen object in the tree.</param>
 /// <param name="poolAncestor">The pool ancestor of the xen object in the tree.</param>
 public SelectedItem(IXenObject xenObject, IXenConnection connection, Host hostAncestor, Pool poolAncestor)
 {
     _xenObject = xenObject;
     _hostAncestor = hostAncestor;
     _poolAncestor = poolAncestor;
     _connection = connection;
 }

 public PoolRef(GameObject src)
 {
     cachedObj = src;
     cachedPool = Pool.Instance;
     if(src != null)
         ptr = cachedPool.GetPoolInstance(src);
 }