Random and temporary adequacy

Question

I'm trying to make my own version of the Fruit Ninja for training based on this version: https://github.com/emmaguy/FruitNinja

I made some minor changes. I want to do to affect the various ratings of the object in the "listing" in fruittype.

So, I am adding this function (in order to get the current random value):

public static int currentrandom() {
    return random.nextInt(FruitType2.values().length );
}

and i add

if (FruitType2.currentrandom()<=9) {
       score++;
} else {
       score=score-5;
   }

at the end of the FruitProjectileManager.

Full code for FruitProjectileManager:

public class FruitProjectileManager02 implements ProjectileManager {

    private final Random random2 = new Random();
    private final List<Projectile> fruitProjectiles =
            new ArrayList<Projectile>();
    private final SparseArray<Bitmap> bitmapCache;
    private Region clip;
    private int maxWidth;
    private int maxHeight;


    private String FruitTypen = "FruitType2";


    public FruitProjectileManager02(Resources r) {

        bitmapCache = new SparseArray<Bitmap>(FruitType2.values().length);

        for (FruitType2 t : FruitType2.values()) {
            bitmapCache.put(t.getResourceId(), BitmapFactory.decodeResource(r, t.getResourceId(), new Options()));
        }
    }

    public void draw(Canvas canvas) {
        for (Projectile f : fruitProjectiles) {
            f.draw(canvas);
        }
    }

    public void update() {

        if (maxWidth < 0 || maxHeight < 0) {
            return;
        }
        if (random2.nextInt(1000) < 30) {
            fruitProjectiles.add(createNewFruitProjectile());
        }

        for (Iterator<Projectile> iter = fruitProjectiles.iterator(); iter.hasNext(); ) {

            Projectile f = iter.next();
            f.move();
            if (f.hasMovedOffScreen()) {
                iter.remove();
            }
        }
    }

    private FruitProjectile02 createNewFruitProjectile() {
        int angle = random2.nextInt(20) + 70;
        int speed = random2.nextInt(30) + 120;
        boolean rightToLeft = random2.nextBoolean();

        float gravity = random2.nextInt(6) + 8.0f;
        float rotationStartingAngle = random2.nextInt(360);
        float rotationIncrement = random2.nextInt(100) / 3.0f;

        if (random2.nextInt(1) % 2 == 0) {
            rotationIncrement *= -1;
        }

        return new FruitProjectile02(bitmapCache.get(FruitType2.randomFruit().getResourceId()), maxWidth, maxHeight,
                angle, speed, gravity, rightToLeft, rotationIncrement, rotationStartingAngle);
    }

    public void setWidthAndHeight(int width, int height) {
        this.maxWidth = width;
        this.maxHeight = height;
        this.clip = new Region(0, 0, width, height);
    }

    @Override
    public int testForCollisions(List<TimedPath> allPaths) {
        int score = 0;
        for (TimedPath p : allPaths) {
            for (Projectile f : fruitProjectiles) {
                if (!f.isAlive())
                    continue;
                Region projectile = new Region(f.getLocation());
                Region path = new Region();
                path.setPath(p, clip);

                if (!projectile.quickReject(path) && projectile.op(path, Region.Op.INTERSECT)) {
                    if (FruitType2.currentrandom() <= 9) {
                        score++;
                    } else {
                        score = score - 5;
                    }
                    f.kill();
                }
            }
        }
        return score;
    }
}

Full code for FruitType:

public enum FruitType2 {
    T02(R.drawable.n002),
    T04(R.drawable.n004),
    T06(R.drawable.n006),
    T08(R.drawable.n008),
    T10(R.drawable.n010),
    T12(R.drawable.n012),
    T14(R.drawable.n014),
    T16(R.drawable.n016),
    T18(R.drawable.n018),
    T20(R.drawable.n020),


    OTHER1(R.drawable.n003),
    OTHER2(R.drawable.n007),
    OTHER3(R.drawable.n011);

    private final int resourceId;

    private FruitType2(int resourceId) {
        this.resourceId = resourceId;
    }

    public int getResourceId() {
        return resourceId;
    }

    private static final Random random = new Random();


    public static int currentrandom() {


        return random.nextInt(FruitType2.values().length);
    }


    public static FruitType2 randomFruit() {


        return FruitType2.values()[random.nextInt(FruitType2.values().length)];
    }
}

I understand the problem, the current randomness (when the fruit is created) is not the same as the random one when the fruit is sliced, and my question is how to solve this problem. I have no idea, so if you have any clues, I'm interested.

Thanks in advance.

Answer 1

, , ? .