Java MathUtils.randomBoolean方法代码示例

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public void part4() {
	if (flag4) {
		flag4 = false;
		existTime = 0;
		moveBasic.velocity.set(0, 0);
		moveBasic.acc.set(0, 0);
		Entity.postUpdate.add(() -> { GameHelper.clearEnemyBullets(); });
	}
	if (existTime > 60) {
		for (int i=0; i<2; i++)
		{
			final int c = MathUtils.random(3);
			final Entity proj = BaseProjectile.Create(transform.position.cpy(), BulletType.FormCircleS, color4s[c]);
			final ImageRenderer renderer = proj.GetComponent(ImageRenderer.class);
			proj.AddComponent(new EnemyJudgeCircle(5));
			proj.AddComponent(new LambdaComponent(() -> {
				renderer.image.setColor(1, 1, 1, alpha4s[c]);
			}, 5));
			proj.AddComponent(new MoveBasic(new Vector2(1, 0).rotate(MathUtils.random(360f)).scl(MathUtils.random(2f, 7f))));
		}
	}
	if (existTime % 20 == 0) {
		for (int i=0; i<4; i++)
			alpha4s[i] = MathUtils.randomBoolean() || alpha4s[i] < 0.4f ? 0.88f : 0.12f;
	}
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private Cloud spawnCloud() {
    Cloud cloud = new Cloud();
    cloud.dimension.set(dimension);
    // 随机选取纹理
    cloud.setRegion(regClouds.random());
    // 位置
    Vector2 pos = new Vector2();
    pos.x = length + 10; // 关卡结束的位置
    pos.y += 1.75; // 基础位置
    // 随机高度位置
    pos.y += MathUtils.random(0.0f, 0.2f)
            * (MathUtils.randomBoolean() ? 1 : -1);
    cloud.position.set(pos);
    return cloud;
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public void part5() {
	if (flag5) {
		flag5 = false;
		existTime = 0;
		moveBasic.velocity.set(0, 0);
		moveBasic.acc.set(0, 0);
		Entity.postUpdate.add(() -> { GameHelper.clearEnemyBullets(); });
		targetp5.set(transform.position.x, 400);
	}
	if (existTime <= 90) {
		GameHelper.snipeVct(transform.position, targetp5, 0, moveBasic.velocity);
		moveBasic.velocity.scl(1 / 45f);
	}
	else {
		if (existTime % 270 > 90) {
			for (int i=0; i<360; i+=90) {
				if (MathUtils.randomBoolean(0.3f)) continue;
				if (i == 0 || i == 180)
					deltap5.set(0, MathUtils.random(-15 * ((existTime % 270 - 90) / 9), 15 * ((existTime % 270 - 90) / 9)));
				else
					deltap5.set(MathUtils.random(-50 * ((existTime % 270 - 90) / 9), 50 * ((existTime % 270 - 90) / 9)), 0);
				final Entity proj = BaseProjectile.Create(transform.position.cpy().add(deltap5), BulletType.FormCircleM, BulletType.ColorBlueLight);
				proj.AddComponent(new EnemyJudgeCircle(12));
				proj.AddComponent(new MoveBasic(deltap5.set(6, 0).rotate(i)));
			}
		}
		else if (existTime % 270 == 0) {
			targetp5.set(MathUtils.random(20, 560), 400);
		}
		else {
			GameHelper.snipeVct(transform.position, targetp5, 0, moveBasic.velocity);
			moveBasic.velocity.scl(1 / 36f);
		}
	}
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public WorldGenerator(int gen_seed, int num_biomes, int map_width) {
    biome_list = new ArrayList<>();
    max_heights = new HashMap<>();
    biome_locations = new HashMap<>();

    /* separation of different biomes */
    Voronoi biomes = new Voronoi();
    biomes.setSeed(gen_seed);
    biomes.setFrequency(0.01);

    /* random variation sprinkled around the terrain */
    Perlin basefluct = new Perlin();
    basefluct.setSeed(gen_seed);
    basefluct.setFrequency(0.02f);

    /* generate the biomes of the world */
    for (int i = 0; i < num_biomes; i++) {
        biome_list.add(new Biome(i));
    }

    /* find which biome will be at each x-value of the world. */
    for (int i = 0; i < map_width; i++) {
        biome_locations.put(i, (int) (Math.abs(biomes.getValue(i, 0, 0)) * num_biomes));
    }

    /* add the base variation to the terrain */
    for (int i = 0; i < map_width; i++) {
        max_heights.put(i, 10 + (int) (Math.abs(basefluct.getValue(i, 0, 0)) * 7));
    }

    /* add hills */
    for (int i = 0; i < map_width; i++) {
        if (MathUtils.randomBoolean(biome_list.get(biome_locations.get(i)).getHilliness())) {
            buildHill(i, MathUtils.random(6, 10));
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private void killDudes() {
    for (E e : allEntitiesWith(Wander.class)) {
        e.removeDolphinized();
        if (MathUtils.randomBoolean()) {
            e.died();
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private void randomizeAnger() {
    for (E e : allEntitiesWith(Wander.class)) {
        e.removeDolphinized();
        if (MathUtils.randomBoolean()) {
            e.removeAngry();
        } else {
            e.angry();
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public Ring createRing(Ring ring) {
    Array<ColorGroup> colors = new Array<ColorGroup>();

    colors.add(new ColorGroup()
            .add(Color.rgba8888(223f / 255f, 233f / 255f, 180f / 255f, 1f))
            .add(Color.rgba8888(170f / 255f, 90f / 255f, 103f / 255f, 1f)));

    colors.add(new ColorGroup()
            .add(Color.rgba8888(191f / 255f, 231f / 255f, 231f / 255f, 1f))
            .add(Color.rgba8888(75f / 255f, 109f / 255f, 133f / 255f, 1f)));

    colors.add(new ColorGroup()
            .add(Color.rgba8888(169f / 255f, 194f / 255f, 175f / 255f, 1f))
            .add(Color.rgba8888(30f / 255f, 97f / 255f, 42f / 255f, 1f)));

    Ring innerRing = ring != null ? ring : previousRing;

    int objectCount = innerRing == null ? MathUtils.random(200, 300) : MathUtils.random(200, 350);
    float angularVelocity = 0;
    float zTilt = innerRing == null ? 30 : innerRing.getZTilt();
    float xTilt = innerRing == null ? -20 : innerRing.getXTilt();
    float minimumRadius = innerRing == null ? scene.getPlanet().getWidthAtY(0) + 25 : innerRing.getMaximumRadius() + 5;
    float maximumRadius = innerRing == null ? minimumRadius + MathUtils.random(20, 60) : minimumRadius + MathUtils.random(20, 50);
    ColorGroup colorGroup = colors.random();

    Array<Orbiter> ringObjects = new Array<>();
    for(int i = 0; i < objectCount; i++) {
        Orbiter.OrbiterBlueprint blueprint = new Orbiter.OrbiterBlueprint();
        blueprint.angularVelocity = angularVelocity;
        blueprint.zTilt = zTilt;
        blueprint.xTilt = xTilt;
        blueprint.angle = MathUtils.random(0, 360);
        blueprint.radius = MathUtils.random(minimumRadius, maximumRadius);

        Orbiter ringObject = null;
        if (MathUtils.randomBoolean(0.9f)) {
            ringObject = new Orbiter(createMoonSprite(MathUtils.random(4, 6)), blueprint, colorGroup.random());
        } else {
            ringObject = new Orbiter(createSquare(MathUtils.random(4, 5)), blueprint, colorGroup.random());
        }
        ringObjects.add(ringObject);
    }

    //scene.addSpaceObjects(ringObjects);

    Ring newRing = new Ring(ringObjects, colorGroup, minimumRadius, maximumRadius);
    scene.addRing(newRing);
    return newRing;
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
public void move(int initX, ParticleSystem particleSystem, VelocitySystem velocitySystem) {
    this.ticked = true;

    /* no need to try moving if every adjacent spot is occupied */
    if (adjacentsFull()) {
        return;
    }

    final int x_location = ((getX() - initX) / VCEL_W) + 1;
    final int y_location = (getY() / VCEL_W) + 1;

    /* move the particle according to the velocity system, so long as it can be affected by wind. */
    if (properties.getWindResistance() != 1) {
        particleSystem.move(
                this,
                (1 - properties.getWindResistance()) * velocitySystem.getXAt(x_location, y_location),
                (1 - properties.getWindResistance()) * velocitySystem.getYAt(x_location, y_location)
        );
    }

    /* the particle can only fall if it is affected by gravity. */
    if (properties.getGravity() != 0) {
        particleSystem.move(this, 0, -properties.getGravity());
    }

    /* other non-gravitational movements e.g. diffusion of gases, flow of liquids. */
    int move_idx = properties.getMove().getMoveChoice();

    if (move_idx != -1 && MathUtils.randomBoolean(properties.getMove().getProbability(move_idx))) {
        switch (move_idx) {
            case 0:
                particleSystem.move(this, -1, 1);
                return;
            case 1:
                particleSystem.move(this, 0, 1);
                return;
            case 2:
                particleSystem.move(this, 1, 1);
                return;
            case 3:
                particleSystem.move(this, -1, 0);
                return;
            case 4:
                particleSystem.move(this, 1, 0);
                return;
            case 5:
                particleSystem.move(this, -1, -1);
                return;
            case 6:
                particleSystem.move(this, 0, -1);
                return;
            case 7:
                particleSystem.move(this, 1, -1);
                return;
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
    public void update(ParticleSystem ps) {
        this.ticked = false;

        if (properties.getLife().isFinite()) {
            System.out.println(life);
            life--;

            if (life < 0) {
                ps.removeParticle(getX(), getY());
            }
        }

        /* no need to try updating the particle if it can't go through any transformations. */
        if (properties.getTransformations() == null) {
            return;
        }

        final Transformation[] transformations = properties.getTransformations();

        /* iterate over each of the possible transformations that the particle can go through */
        for (int i = 0; i < transformations.length; i++) {
            final Transformation transformation = transformations[i];
            boolean canTransform = true;

            /* iterate over the required type and number of particle needed for this transformation. */
            for (int j = 0; j < transformation.getTypesNeeded().length; j++) {
                /* if one of the checks fails, we know that the transform can't occur, so we break */
                if (!containsN(transformation.getTypesNeeded()[j], transformation.getNumbersNeeded()[j])) {
                    canTransform = false;
                    break;
                }
            }

            /* if we can't use this transformation, we move to the next one. */
            if (!canTransform) {
                continue;
            }

            /* toss a biased coin to see if we can transform the particle. */
            if (MathUtils.randomBoolean(transformation.getProbability())) {
//                ps.addParticle(new Particle(transformation.getTypeProduced(), x, y));
                /* if the transformation occurred, see if we can remove any adjacent particles. */
                // TODO
            }

            /* only one transformation can be applied. return after one has been applied. */
            return;
        }
    }