Java 控制精灵如何添加到AndEngine中场景的概率

我试图控制在游戏场景中选择精灵的百分比

我有四个精灵是根据较高的百分比挑选的。我希望能够在整个游戏中改变百分比。我需要在每次调用该方法时将一个精灵添加到场景中。我有一个计时器，大约每2秒调用一次该方法。我需要的s雪碧，以增加每次的百分比为基础

这是我到目前为止所做的，但工作不正常。增加百分比并不会增加添加精灵的概率。它有时增加了错误的一个，有时根本不起作用。我知道必须有更好更简单的方法来做到这一点

有人有什么想法吗

下面是我向场景添加精灵的方法

private void addSprite() {
    switch (pickSprite()) {
    // Persons Sprite with area touched code
    case 1:
        red_Sprite = red_pool.obtainPoolItem();
        SequenceEntityModifier loop1 = new SequenceEntityModifier(
                    new RotationModifier(.5f, 0, -5),
                    new RotationModifier(.5f, -5, 5),
                    new RotationModifier(.5f, 5, 0));
        red_Sprite.registerEntityModifier(new LoopEntityModifier(loop1));
        scene.registerTouchArea(red_Sprite);
        if (!red_Sprite.hasParent())
            scene.getFirstChild().attachChild(red_Sprite);
        else
            red_Sprite.setVisible(true);
        red_personList.add(red_Sprite);
        break;
    case 2:
    // Persons Sprite with area touched code
        green_Sprite = green_pool.obtainPoolItem();
        SequenceEntityModifier loop2 = new SequenceEntityModifier(
                    new RotationModifier(.5f, 0, -5),
                    new RotationModifier(.5f, -5, 5),
                    new RotationModifier(.5f, 5, 0));
        green_Sprite.registerEntityModifier(new LoopEntityModifier(loop2));
        scene.registerTouchArea(green_Sprite);
        if (!green_Sprite.hasParent())
            scene.getFirstChild().attachChild(green_Sprite);
        else
            green_Sprite.setVisible(true);
        green_personList.add(green_Sprite);
        break;
    case 3:
    // Persons Sprite with area touched code
        orange_Sprite = orange_pool.obtainPoolItem();
        SequenceEntityModifier loop = new SequenceEntityModifier(
                    new RotationModifier(.5f, 0, -5),
                    new RotationModifier(.5f, -5, 5),
                    new RotationModifier(.5f, 5, 0));
        orange_Sprite.registerEntityModifier(new LoopEntityModifier(loop));
        scene.registerTouchArea(orange_Sprite);
        if (!orange_Sprite.hasParent())
            scene.getFirstChild().attachChild(orange_Sprite);
        else
            orange_Sprite.setVisible(true);
        orange_personList.add(orange_Sprite);
        break;
    case 4:
    // Persons Sprite with area touched code
        blue_Sprite = blue_pool.obtainPoolItem();
        SequenceEntityModifier loop4 = new SequenceEntityModifier(
                    new RotationModifier(.5f, 0, -5),
                    new RotationModifier(.5f, -5, 5),
                    new RotationModifier(.5f, 5, 0));
        blue_Sprite.registerEntityModifier(new LoopEntityModifier(loop4));
        scene.registerTouchArea(blue_Sprite);
        if (!blue_Sprite.hasParent())
            scene.getFirstChild().attachChild(blue_Sprite);
        else
            blue_Sprite.setVisible(true);
        blue_personList.add(blue_Sprite);
        break;
    }

以下是我的“拾取精灵”方法：

public int pickSprite() {
    double rand = Math.random();
    for (int i = 0; i < mOdds.length; i++) {
        if (rand < mOdds[i])
            return i;
        rand -= mOdds[i];
    }
    return -1; // should never reach this
}

public int pickSprite（）{
double rand=Math.random（）；
for（int i=0；i

这里是我的方法，我试图增加被添加精灵的几率或百分比

public void increaseOdds(int index, double value) {
    double valueFromIndex = mOdds[index];
    mOdds[index] += value;
    // Make sure odds don't turn mOdds to less than zero
    if (mOdds[index] < 0.0) {
        value = value - mOdds[index];
        mOdds[index] = 0.0;
    } else if (mOdds[index] > 1.0) {
        value = mOdds[index] - 1;
        mOdds[index] = 1.0;
    }
    double changeToOthers = value / 3;
    double extraForNext = 0.0f;
    for (int i = 0; i < mOdds.length; i++) {
        if (i != index) {
            mOdds[i] -= changeToOthers;
            if (mOdds[i] < 0) {
                extraForNext = mOdds[i];
                mOdds[i] = 0.0;
            } else if (mOdds[i] > 1) {
                extraForNext = 1 - mOdds[i];
                mOdds[i] = 1.0;
            } else {
                mOdds[i] += extraForNext;
            }
        }
    }
}

public void递增赔率（整数索引，双倍值）{
双值fromIndex=mOdds[index]；
mOdds[索引]+=值；
//确保赔率不会将mOdds变为小于零
if（mOdds[index]<0.0）{
值=值-mOdds[索引]；
mOdds[index]=0.0；
}else if（mOdds[index]>1.0）{
值=mOdds[index]-1；
mOdds[index]=1.0；
}
双换齿器=值/3；
双extraForNext=0.0f；
for（int i=0；i1）{
extraForNext=1—mOdds[i]；
mOdds[i]=1.0；
}否则{
mOdds[i]+=extraForNext；
}
}
}
}

我发现有一些问题是由

增加赔率（）

引起的。假设您在

索引0

，

值0.6

上调用它，并且

mOdds[0]

当前等于0.8。然后，您的代码将两者相加，给出

mOdds[0]=1.4

。然后减去1，赋值为

value=0.4

，即使实际上只改变了0.2。因此，最终将0.2添加到索引中，并将其他三个值拆分为-0.4，使它们不等于1

另外，如果最后一个元素是给你“额外”数量的元素，会发生什么？在循环数组之后，需要检查并将其分配给另一个数组

试试这个尺码，看看它对你有什么好处。我在纸上和笔上用一些奇数来测试它，它似乎挺得住：

编辑：更改了一些代码

public void changeOdds(int index, double value) 
{
    double old = mOdds[index];
            mOdds[index] = value;

    if(mOdds[index] > 1)
        mOdds[index] = 1;
    if(mOdds[index] < 0)
        mOdds[index] = 0;   

    double changeToOthers = (mOdds[index] - old) / -3.0;
    double extra = 0;
    for(int i=0;i<mOdds.length;i++)
    {
        if(i == index)
            continue;
        double add = changeToOthers + extra;
        if(mOdds[i] + add > 1)
        {
            extra = 1 - mOdds[i];
            mOdds[i] = 1;
        } else if(mOdds[i] + add < 0)
        {       
            extra = -mOdds[i];
            mOdds[i] = 0
        } else
        {
            mOdds += add;
            extra = 0;
        }
    }   
            // if there's still a negative extra, assign it to the first non-index that can take it and stop
    if(extra < 0)
    {
        for(int i=0;i<mOdds.length;i++)
        {
            if(i == index)
                continue;
            if(mOdds[i] + extra >= 0)
            {
                mOdds[i] += extra;
                extra = 0;
                break;
            }
        }
    }
            // ditto for positive extras
    if(extra > 0)
    {
        for(int i=0;i<mOdds.length;i++)
        {
            if(i == index)
                continue;
            if(mOdds[i] + extra <= 1)
            {
                mOdds[i] += extra;
                extra = 0;
                break;
            }
        }
    }
}

public void changeoff（整数索引，双值）
{
双旧=mOdds[索引]；
mOdds[索引]=值；
如果（mOdds[索引]>1）
mOdds[index]=1；
if（mOdds[index]<0）
mOdds[index]=0；
双换向器=（mOdds[索引]-旧版）/-3.0；
双倍额外=0；
对于（int i=0；i 1）
{
额外=1-mOdds[i]；
mOdds[i]=1；
}else if（mOdds[i]+add<0）
{       
额外=-mOdds[i]；
mOdds[i]=0
}否则
{
mOdds+=add；
额外=0；
}
}   
//如果仍然有一个负的额外值，则将其分配给第一个可以接受它并停止的非索引
如果（额外<0）
{
对于（int i=0；i=0）
{
mOdds[i]+=额外；
额外=0；
打破
}
}
}
//积极的额外费用也一样
如果（额外>0）
{
对于（int i=0；我感谢你的努力，但当我尝试增加赔率（0.38）时，它仍然会将结果更改为.48。在你调用
increasedoffics（）之前是什么
？我假设函数应该将其添加到当前赔率中，而不是替换它。哦，不，它应该替换当前的奇数…好的，为了将来参考，当您命名函数时，第一行是
mOdds[index]+=value；
，人们自然会认为应该添加它们，而不是替换。编辑我的代码以反映。