private Arrow SpawnArrow(float range, Arrow.arrowType typeOfArrow)
    {
        GridBlock gb = null;

        while (gb == null)
        {
            gb = GetEmptyIsolatedGridBlock(range);
        }

        if (gb.isOccupied || gb.hasItem)
        {
            return(null);
        }

        GameObject prefab;

        switch (typeOfArrow)
        {
        case Arrow.arrowType.Quadruple:
            prefab = arrows_prefabs[2];
            break;

        case Arrow.arrowType.Double:
            prefab = arrows_prefabs[1];
            break;

        case Arrow.arrowType.Single:
        default:
            prefab = arrows_prefabs[0];
            break;
        }
        GameObject arrowPrefab = Instantiate(prefab, getGridBlockPosition(gb.X, gb.Z, 0.8f), Quaternion.identity) as GameObject;
        Arrow      a           = arrowPrefab.GetComponent <Arrow> ();

        a.grid_ref         = GetComponent <TheGrid> ();
        a.rhythmSystem_ref = rhythmSystem_ref;
        a.arrow_type       = typeOfArrow;
        a.gridBlockOwner   = gb;

        rhythmSystem_ref.getRhythmNoteToPoolEvent().AddListener(a.IncreaseCount);
        a.x = gb.X;
        a.y = gb.Y;
        a.z = gb.Z;

        gb.hasItem = true;
        itemList.Add(a);

        return(a);
    }
    void itemTimersUpdate()
    {
        if (scoreMakerTimer.stop)
        {
            if (isRandomScoreMakerSpawnTime)
            {
                scoreMakerTimer.startTimer(Random.Range(ScoreMakerSpawnTimeMin, ScoreMakerSpawnTimeMax));
            }
            else
            {
                scoreMakerTimer.startTimer((ScoreMakerSpawnTimeMax + ScoreMakerSpawnTimeMin) / 2);
            }

            // if more than 5 scoremakers in the stage
            if (itemList.OfType <ScoreMaker> ().Count() < scoreMakerCountLimit)
            {
                ScoreMaker sm = SpawnScoreMaker(2.0f);
            }
        }

        if (arrowTimer.stop)
        {
            if (isRandomLockSpawnTime)
            {
                lockTimer.startTimer(Random.Range(lockSpawnTimeMin, lockSpawnTimeMax));
            }
            else
            {
                lockTimer.startTimer((lockSpawnTimeMin + lockSpawnTimeMax) / 2);
            }

            // if more than 5 scoremakers in the stage
            if (itemList.OfType <Lock> ().Count() < lockCountLimit)
            {
                Lock sm = SpawnLock(2.0f);
            }
        }

        if (arrowTimer.stop)
        {
            if (isRandomArrowSpawnTime)
            {
                arrowTimer.startTimer(Random.Range(ArrowSpawnTimeMin, ArrowSpawnTimeMax));
            }
            else
            {
                arrowTimer.startTimer((ArrowSpawnTimeMin + ArrowSpawnTimeMax) / 2);
            }

            if (itemList.OfType <Arrow> ().Count() < arrowCountLimit)
            {
                float           ratioTotal = singleArrowRatio + doubleArrowRatio + quadrupleArrowRatio;
                float           ar         = Random.Range(0f, ratioTotal);
                Arrow.arrowType t          = Arrow.arrowType.Single;
                if ((ar - quadrupleArrowRatio) < 0)
                {
                    t = Arrow.arrowType.Quadruple;
                }
                else if ((ar - doubleArrowRatio) < 0)
                {
                    t = Arrow.arrowType.Double;
                }
                else if ((ar - singleArrowRatio) < 0)
                {
                    t = Arrow.arrowType.Single;
                }

                Arrow sm = SpawnArrow(1.0f, t);
            }
        }
    }