Java Code Examples for com.badlogic.ashley.core.Engine#addSystem()

@Test
public void intervalSystem () {
	Engine engine = new Engine();
	IntervalIteratingSystemSpy intervalSystemSpy = new IntervalIteratingSystemSpy();
	ImmutableArray<Entity> entities = engine.getEntitiesFor(Family.all(IntervalComponentSpy.class).get());
	ComponentMapper<IntervalComponentSpy> im = ComponentMapper.getFor(IntervalComponentSpy.class);

	engine.addSystem(intervalSystemSpy);

	for (int i = 0; i < 10; ++i) {
		Entity entity = new Entity();
		entity.add(new IntervalComponentSpy());
		engine.addEntity(entity);
	}

	for (int i = 1; i <= 10; ++i) {
		engine.update(deltaTime);

		for (int j = 0; j < entities.size(); ++j) {
			assertEquals(i / 2, im.get(entities.get(j)).numUpdates);
		}
	}
}
 

/**
 * Setup a whole bunch of shit.
 */
public static void setup() {
  engine = new Engine();
  log = new ActionLog();
  world = new World();
  tweens = new Array<>();

  entityFactory = new EntityFactory();
  inputHelpers = new InputHelpers();
  mapHelpers = new MapHelpers();
  entityHelpers = new EntityHelpers();
  itemHelpers = new ItemHelpers();
  combatHelpers = new CombatHelpers();

  executeTurn = false;
  turnCount = 0;

  // Setup engine (systems are run in order added)
  engine.addSystem(new AttributesSystem());
  engine.addSystem(new AbilitiesSystem());
  engine.addSystem(new MouseMovementSystem());
  engine.addSystem(new ExploreSystem());
  engine.addSystem(new BrainSystem());
  engine.addSystem(new RangeSystem());
  engine.addSystem(new MeleeSystem());
  engine.addSystem(new MovementSystem());
  engine.addSystem(new TileEffectSystem());
  engine.addSystem(new EncumberedSystem());
  engine.addSystem(new CharmedSystem());
  engine.addSystem(new CrippledSystem());
  engine.addSystem(new BleedingSystem());
  engine.addSystem(new BurningSystem());
  engine.addSystem(new DrowningSystem());
  engine.addSystem(new StuckSystem());
  engine.addSystem(new PoisonedSystem());
  engine.addSystem(new SickSystem());
  engine.addSystem(new WetSystem());
  engine.addSystem(new DeathSystem());
}
 

@Setup
public void init() {
	engine = new Engine();
	engine.addSystem(new PlainPositionSystem());
	engine.addSystem(new PlainPositionSystem2());
	engine.addSystem(new PlainPositionSystem3());
	engine.addSystem(new EntityDeleterSystem(JmhSettings.SEED, entityCount, PlainPosition.class, PlainStructComponentA.class));
}
 

@Setup
public void init() {
	engine = new Engine();
	engine.addSystem(new EntityDeleterSystem(SEED, entityCount, PlainPosition.class, PlainStructComponentA.class));
	engine.addSystem(new BaselinePositionSystem());
	engine.addSystem(new BaselinePositionSystem2());
	engine.addSystem(new BaselinePositionSystem3());
}
 

@Setup
public void init() throws Exception {
	engine = new Engine();
	engine.addSystem(new EntityManglerSystem(SEED, entityCount));
	engine.addSystem(new CompSystemA());
	engine.addSystem(new CompSystemB());
	engine.addSystem(new CompSystemC());
	engine.addSystem(new CompSystemD());
}
 

@Test
@SuppressWarnings("unchecked")
public void shouldIterateEntitiesWithCorrectFamily () {
	final Engine engine = new Engine();

	final Family family = Family.all(ComponentA.class, ComponentB.class).get();
	final IteratingSystemMock system = new IteratingSystemMock(family);
	final Entity e = new Entity();

	engine.addSystem(system);
	engine.addEntity(e);

	// When entity has ComponentA
	e.add(new ComponentA());
	engine.update(deltaTime);

	assertEquals(0, system.numUpdates);

	// When entity has ComponentA and ComponentB
	system.numUpdates = 0;
	e.add(new ComponentB());
	engine.update(deltaTime);

	assertEquals(1, system.numUpdates);

	// When entity has ComponentA, ComponentB and ComponentC
	system.numUpdates = 0;
	e.add(new ComponentC());
	engine.update(deltaTime);

	assertEquals(1, system.numUpdates);

	// When entity has ComponentB and ComponentC
	system.numUpdates = 0;
	e.remove(ComponentA.class);
	e.add(new ComponentC());
	engine.update(deltaTime);

	assertEquals(0, system.numUpdates);
}
 

@Test
@SuppressWarnings("unchecked")
public void shouldIterateEntitiesWithCorrectFamily () {
	final Engine engine = new Engine();

	final Family family = Family.all(OrderComponent.class, ComponentB.class).get();
	final SortedIteratingSystemMock system = new SortedIteratingSystemMock(family);
	final Entity e = new Entity();

	engine.addSystem(system);
	engine.addEntity(e);

	// When entity has OrderComponent
	e.add(new OrderComponent("A", 0));
	engine.update(deltaTime);

	// When entity has OrderComponent and ComponentB
	e.add(new ComponentB());
	system.expectedNames.addLast("A");
	engine.update(deltaTime);

	// When entity has OrderComponent, ComponentB and ComponentC
	e.add(new ComponentC());
	system.expectedNames.addLast("A");
	engine.update(deltaTime);

	// When entity has ComponentB and ComponentC
	e.remove(OrderComponent.class);
	e.add(new ComponentC());
	engine.update(deltaTime);
}
 

@Test
public void entityOrder () {
	Engine engine = new Engine();

	final Family family = Family.all(OrderComponent.class).get();
	final SortedIteratingSystemMock system = new SortedIteratingSystemMock(family);
	engine.addSystem(system);

	Entity a = createOrderEntity("A", 0);
	Entity b = createOrderEntity("B", 1);
	Entity c = createOrderEntity("C", 3);
	Entity d = createOrderEntity("D", 2);

	engine.addEntity(a);
	engine.addEntity(b);
	engine.addEntity(c);
	system.expectedNames.addLast("A");
	system.expectedNames.addLast("B");
	system.expectedNames.addLast("C");
	engine.update(0);

	engine.addEntity(d);
	system.expectedNames.addLast("A");
	system.expectedNames.addLast("B");
	system.expectedNames.addLast("D");
	system.expectedNames.addLast("C");
	engine.update(0);

	orderMapper.get(a).zLayer = 3;
	orderMapper.get(b).zLayer = 2;
	orderMapper.get(c).zLayer = 1;
	orderMapper.get(d).zLayer = 0;
	system.forceSort();
	system.expectedNames.addLast("D");
	system.expectedNames.addLast("C");
	system.expectedNames.addLast("B");
	system.expectedNames.addLast("A");
	engine.update(0);
}
 

@Test
public void intervalSystem () {
	Engine engine = new Engine();
	IntervalSystemSpy intervalSystemSpy = new IntervalSystemSpy();

	engine.addSystem(intervalSystemSpy);

	for (int i = 1; i <= 10; ++i) {
		engine.update(deltaTime);
		assertEquals(i / 2, intervalSystemSpy.numUpdates);
	}
}
 

public static void main (String[] args) {
	Engine engine = new Engine();

	engine.addSystem(new SystemA(10));
	engine.addSystem(new SystemB(5));
	engine.addSystem(new SystemA(2));

	engine.update(0);
}
 

@Override
public void show() {
    camera = new OrthographicCamera();
    viewport = new FitViewport(WIDTH, HEIGHT, camera);
    camera.translate(WIDTH / 2, HEIGHT / 2);
    camera.update();

    batch = new SpriteBatch();

    playerSystem = new PlayerSystem();
    ghostSystem = new GhostSystem();
    movementSystem = new MovementSystem();
    pillSystem = new PillSystem();
    animationSystem = new AnimationSystem();
    renderSystem = new RenderSystem(batch);
    stateSystem = new StateSystem();

    engine = new Engine();
    engine.addSystem(playerSystem);
    engine.addSystem(ghostSystem);
    engine.addSystem(pillSystem);
    engine.addSystem(movementSystem);
    engine.addSystem(stateSystem);
    engine.addSystem(animationSystem);
    engine.addSystem(renderSystem);

    // box2d
    world = new World(Vector2.Zero, true);
    world.setContactListener(new WorldContactListener());
    box2DDebugRenderer = new Box2DDebugRenderer();
    showBox2DDebuggerRenderer = false;

    // box2d light
    rayHandler = new RayHandler(world);
    rayHandler.setAmbientLight(ambientLight);

    // load map
    tiledMap = new TmxMapLoader().load("map/map.tmx");
    tiledMapRenderer = new OrthogonalTiledMapRenderer(tiledMap, 1 / 16f, batch);

    new WorldBuilder(tiledMap, engine, world, rayHandler).buildAll();

    stageViewport = new FitViewport(WIDTH * 20, HEIGHT * 20);
    stage = new Stage(stageViewport, batch);

    font = new BitmapFont(Gdx.files.internal("fonts/army_stencil.fnt"));
    Label.LabelStyle labelStyle = new Label.LabelStyle(font, Color.WHITE);

    Label scoreTextLabel = new Label("SCORE", labelStyle);
    scoreTextLabel.setPosition(WIDTH * 1, HEIGHT * 19);
    stage.addActor(scoreTextLabel);

    Label hightScoreTextLabel = new Label("High Score", labelStyle);
    hightScoreTextLabel.setPosition(WIDTH * 14, HEIGHT * 19);
    stage.addActor(hightScoreTextLabel);

    scoreLabel = new Label("0", labelStyle);
    scoreLabel.setPosition(WIDTH * 1.5f, HEIGHT * 18.2f);
    stage.addActor(scoreLabel);

    highScoreLabel = new Label("0", labelStyle);
    highScoreLabel.setPosition(WIDTH * 16.5f, HEIGHT * 18.2f);
    stage.addActor(highScoreLabel);

    gameOverLabel = new Label("              - Game Over -\n Press Enter to continue", labelStyle);
    gameOverLabel.setPosition(WIDTH * 4.3f, HEIGHT * 9f);
    gameOverLabel.setVisible(false);
    stage.addActor(gameOverLabel);

    TextureAtlas textureAtlas = GameManager.instance.assetManager.get("images/actors.pack", TextureAtlas.class);
    pacmanSprite = new Sprite(new TextureRegion(textureAtlas.findRegion("Pacman"), 16, 0, 16, 16));
    pacmanSprite.setBounds(8f, 21.5f, 16 / GameManager.PPM, 16 / GameManager.PPM);

    stringBuilder = new StringBuilder();

    changeScreen = false;
}
 

private static Engine prepareEngine (int numEntities) {
	Engine engine = new Engine();

	engine.addSystem(new MovementSystem());
	engine.addSystem(new StateSystem());
	engine.addSystem(new CollisionSystem());
	engine.addSystem(new RemovalSystem());

	for (int i = 0; i < numEntities; ++i) {
		Entity entity = new Entity();

		if (Constants.shouldHaveComponent(ComponentType.POSITION, i)) {
			PositionComponent pos = new PositionComponent();
			pos.pos.x = MathUtils.random(Constants.MIN_POS, Constants.MAX_POS);
			pos.pos.y = MathUtils.random(Constants.MIN_POS, Constants.MAX_POS);
			entity.add(pos);
		}

		if (Constants.shouldHaveComponent(ComponentType.MOVEMENT, i)) {
			MovementComponent mov = new MovementComponent();
			mov.velocity.x = MathUtils.random(Constants.MIN_VEL, Constants.MAX_VEL);
			mov.velocity.y = MathUtils.random(Constants.MIN_VEL, Constants.MAX_VEL);
			mov.accel.x = MathUtils.random(Constants.MIN_ACC, Constants.MAX_ACC);
			mov.accel.y = MathUtils.random(Constants.MIN_ACC, Constants.MAX_ACC);

			entity.add(mov);
		}

		if (Constants.shouldHaveComponent(ComponentType.RADIUS, i)) {
			RadiusComponent rad = new RadiusComponent();
			rad.radius = MathUtils.random(Constants.MIN_RADIUS, Constants.MAX_RADIUS);
			entity.add(rad);
		}

		if (Constants.shouldHaveComponent(ComponentType.STATE, i)) {
			entity.add(new StateComponent());
		}

		engine.addEntity(entity);
	}

	return engine;
}