cocos2d实现SlotMachine（老*虎*机）

    实现一个四个转子，每个转子有五个花色的老*虎机。转子的转动实现原理很简单，和背景图无限滚动的原理是一样的：排成列的精灵在屏幕上向上滚动，再通过裁剪结点的裁剪就造成了转子滚动的效果。

void LayerSlotMachine::on_btn_roll(CCObject* pSender, CCControlEvent event)
{
    if (!flag_act_)
    {
        schedule(schedule_selector(XLayerSlotMachine::roll_update));
        stop_flag_ = 0;
        int target_index;
        float mov_dis;

        target_index = rand() % 5;
        CCLOG("slot1:%d", target_index);
        mov_dis = get_mov_dis(target_index, cur_index1_);
        cur_index1_ = target_index;
        roll_act_start(array_1_, mov_dis);

        target_index = rand() % 5;
        CCLOG("slot2:%d", target_index);
        mov_dis = get_mov_dis(target_index, cur_index2_);
        cur_index2_ = target_index;
        roll_act_start(array_2_, mov_dis);

        target_index = rand() % 5;
        CCLOG("slot3:%d", target_index);
        mov_dis = get_mov_dis(target_index, cur_index3_);
        cur_index3_ = target_index;
        roll_act_start(array_3_, mov_dis);

        target_index = rand() % 5;
        CCLOG("slot4:%d", target_index);
        mov_dis = get_mov_dis(target_index, cur_index4_);
        cur_index4_ = target_index;
        roll_act_start(array_4_, mov_dis);

        flag_act_ = true;
    }
}

void LayerSlotMachine::roll_act_start(CCArray* aray,float mov_dis)
{
    CCObject* obj;
    CCARRAY_FOREACH(aray, obj)
    {
        CCCallFunc* act_end = CCCallFunc::create(this, callfunc_selector(XLayerSlotMachine::roll_act_end));
        CCSequence* seq1 = CCSequence::create(CCMoveBy::create(mov_dis/rotate_v_, ccp(0, mov_dis))
            , act_end
            , NULL);
        CCSprite* spr = (CCSprite*)obj;
        spr->runAction(seq1);
    }
}

void LayerSlotMachine::roll_update(float dt)
{
    roll_bound_test(array_1_,node_slot_1_, 1);
    roll_bound_test(array_2_,node_slot_2_, 2);
    roll_bound_test(array_3_,node_slot_3_, 3);
    roll_bound_test(array_4_,node_slot_4_, 4);
}

void LayerSlotMachine::roll_act_end()
{
    ++stop_flag_;
    if (stop_flag_==slot_length_*4)
    {
        flag_act_ = false;
        unschedule(schedule_selector(XLayerSlotMachine::roll_update));
    }
}

需要注意的问题有两个：

（1）移动距离的计算

　　　　

float LayerSlotMachine::get_mov_dis(int target_index, int cur_index)
{
    float mov_dis;
    float slot_height = spr_model_->getContentSize().height;
    int T = 7;
    if (target_index > cur_index)
    {
        mov_dis = slot_height*(slot_length_*T + (target_index - cur_index));
    }
    else
    {
        mov_dis = slot_height*(slot_length_*T + (slot_length_ - (cur_index - target_index)));
    }
    return mov_dis;
}

T:周期数

slot_height:转子的高度

slot_length:单个转子上花色的数量，本例是5

target_index:目标位置

cur_index:当前位置

这里对移动距离分两种情况计算：当target_index>cur_index时，在当前周期就能移动到指定的位置，需要移动的格数为（target_index - cur_index）；

当target_index<cur_index时，由于转子只能向上滚动，所以要在下个周期才能达到指定的位置，需要移动的格数为

（(slot_length_ - (cur_index - target_index))）。

 

(2)转子滚动的处理

void LayerSlotMachine::roll_bound_test(CCArray* arry,CCNode* node_slot, int slot_num)
{
    CCObject* obj;
    float bound_y = spr_model_->getContentSize().height*(slot_length_ - 2);

    CCARRAY_FOREACH(arry, obj)
    {
        CCSprite* spr = (CCSprite*)obj;

        if (spr->getPositionY() > bound_y)
        {
            if (spr->getTag() - 1000*slot_num == 0)
            {
                CCSprite* spr0 = (CCSprite*)node_slot->getChildByTag(1000*slot_num + slot_length_ - 1);
                spr->setPositionY(spr0->getPositionY() - spr_model_->getContentSize().height);
            }
            else
            {
                CCSprite* spr0 = (CCSprite*)node_slot->getChildByTag(spr->getTag() - 1);
                spr->setPositionY(spr0->getPositionY() - spr_model_->getContentSize().height);
            }
        }
    }
}

 当精灵位置高于边界高度boundY时，将精灵移到上一个精灵的下方，实现循环滚动。这里需要特别注意应该以上一个精灵的位置作为基准，否则会产生偏移。