Java ImmutableArray类代码示例

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
private void placeTowers(int button) {
	if (_isPlacementMode) {
		Tile tile = getTileAtMouse();
		ImmutableArray<Entity> towerEntitys = getAshleyEngine().getEntitiesFor(_towerFamily);
		Entity first = towerEntitys.first();
		first.remove(MouseImageComponent.class);
		first.getComponent(PositionComponent.class).position.x = tile.getCords().x;
		first.getComponent(PositionComponent.class).position.y = tile.getCords().y;
		first.add(new OffsetComponent(16, 16));
		tile.setType(TileType.WALL);
		tile.setEntity(first);
		getAshleyEngine().getSystem(TowerPlacementSystem.class).tintTile(null);
		InputHandler.setPlacementMode(false);
		_ef.getPlayer().getComponent(MoneyComponent.class).money -= first.getComponent(TowerStatComponent.class)._buyCost;
	}
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@Override
public Vector3f calcForce(Entity target, ImmutableArray<Entity> neighbours) {
	Pose p = target.getComponent(Pose.class);
	
	Vector3f approximatePos = new Vector3f(p.position);
	approximatePos.add(p.velocity);	// add velocity to position to estimate future position
	
	float nearestCurveValue = curve.approximate(new Vector3(approximatePos.x,approximatePos.y,approximatePos.z));

	Vector3f desired_velocity = new Vector3f();
	if(!Float.isNaN(nearestCurveValue)){
		Vector3 point = new Vector3();
		curve.valueAt(point, nearestCurveValue);
		Vector3f nearestCurvePoint = new Vector3f(point.x, point.y, point.z);
		Vector3f positionToNearestCurvePoint = nearestCurvePoint.sub(p.position);
		if(positionToNearestCurvePoint.lengthSquared() >= pathRadius){
			desired_velocity = positionToNearestCurvePoint.normalize().mul(Boid.maxSpeed);
		}else{
			desired_velocity.zero();
		}
	}
	
	return desired_velocity.mul(weight);
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
/**
 * Updates all the systems in this Engine.
 * @param deltaTime The time passed since the last frame.
 */
public void update(float deltaTime){
	if (updating) {
		throw new IllegalStateException("Cannot call update() on an Engine that is already updating.");
	}
	
	updating = true;
	ImmutableArray<EntitySystem> systems = systemManager.getSystems();
	for (int i = 0; i < systems.size(); ++i) {
		EntitySystem system = systems.get(i);
		
		if (system.checkProcessing()) {
			system.update(deltaTime);
		}

		componentOperationHandler.processOperations();
		entityManager.processPendingOperations();
	}
	updating = false;
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
private ImmutableArray<Entity> registerFamily(Family family) {
	ImmutableArray<Entity> entitiesInFamily = immutableFamilies.get(family);

	if (entitiesInFamily == null) {
		Array<Entity> familyEntities = new Array<Entity>(false, 16);
		entitiesInFamily = new ImmutableArray<Entity>(familyEntities);
		families.put(family, familyEntities);
		immutableFamilies.put(family, entitiesInFamily);
		entityListenerMasks.put(family, new Bits());

		for (Entity entity : entities){
			updateFamilyMembership(entity);
		}
	}

	return entitiesInFamily;
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@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);
		}
	}
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@Test
public void systemUpdateOrder () {
	Array<Integer> updates = new Array<Integer>();

	SystemListenerSpy systemSpy = new SystemListenerSpy();
	SystemManager manager = new SystemManager(systemSpy);
	EntitySystemMock system1 = new EntitySystemMockA(updates);
	EntitySystemMock system2 = new EntitySystemMockB(updates);

	system1.priority = 2;
	system2.priority = 1;

	manager.addSystem(system1);
	manager.addSystem(system2);

	ImmutableArray<EntitySystem> systems = manager.getSystems();
	assertEquals(system2, systems.get(0));
	assertEquals(system1, systems.get(1));
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@Test
public void entityForFamilyWithRemoval () {
	// Test for issue #13
	Engine engine = new Engine();

	Entity entity = new Entity();
	entity.add(new ComponentA());

	engine.addEntity(entity);

	ImmutableArray<Entity> entities = engine.getEntitiesFor(Family.all(ComponentA.class).get());

	assertEquals(1, entities.size());
	assertTrue(entities.contains(entity, true));

	engine.removeEntity(entity);

	assertEquals(0, entities.size());
	assertFalse(entities.contains(entity, true));
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@Test
public void entitySystemRemovalWhileIterating () {
	Engine engine = new Engine();

	engine.addSystem(new CounterSystem());

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

	ImmutableArray<Entity> entities = engine.getEntitiesFor(Family.all(CounterComponent.class).get());

	for (int i = 0; i < entities.size(); ++i) {
		assertEquals(0, entities.get(i).getComponent(CounterComponent.class).counter);
	}

	engine.update(deltaTime);

	for (int i = 0; i < entities.size(); ++i) {
		assertEquals(1, entities.get(i).getComponent(CounterComponent.class).counter);
	}
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
@Test
public void getEntities () {
	int numEntities = 10;
	
	Engine engine = new Engine();
	
	Array<Entity> entities = new Array<Entity>();
	
	for (int i = 0; i < numEntities; ++i) {
		Entity entity = new Entity();
		entities.add(entity);
		engine.addEntity(entity);
	}
	
	ImmutableArray<Entity> engineEntities = engine.getEntities();
	
	assertEquals(entities.size, engineEntities.size());
	
	for (int i = 0; i < numEntities; ++i) {
		assertEquals(entities.get(i), engineEntities.get(i));
	}
	
	engine.removeAllEntities();
	
	assertEquals(0, engineEntities.size());
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public static void clearTarget (Entity target) {
	ImmutableArray<Entity> entities = engine.getEntitiesFor(Family.all(TargetComponent.class).get());
	
	for (Entity entity : entities) {
		TargetComponent targetComp = Components.TARGET.get(entity);
		if (targetComp.getTarget() == target) {
			targetComp.setTarget(null);

			//Dispatch a message to the entites FSM that there target was removed from the engine
			if (Components.FSM.has(entity)) {
				FSMComponent fsm = Components.FSM.get(entity);
				MessageManager.getInstance().dispatchMessage(null, fsm, TelegramMessage.TARGET_REMOVED.ordinal(), target);
			}
		}

	}
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public void clearTarget (Entity target) {
	ImmutableArray<Entity> entities = engine.getEntitiesFor(Family.all(TargetComponent.class, SquadComponent.class).get());
	
	for (Entity squad : entities) {
		SquadComponent squadComp = Components.SQUAD.get(squad);
		squadComp.untrack(squad, target);	//The squad no longer will track the target
		
		TargetComponent targetComp = Components.TARGET.get(squad);
		//If we were targeting that squad we remove it from our target
		if (targetComp.getTarget() == target) {
			targetComp.setTarget(null);

			//Dispatch a message to the entites FSM that there target was removed from the engine
			if (Components.FSM.has(squad)) {
				FSMComponent fsm = Components.FSM.get(squad);
				MessageManager.getInstance().dispatchMessage(null, fsm, TelegramMessage.TARGET_REMOVED.ordinal(), target);
			}
		}

	}
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public static Entity closestEntity(Vector3 position, ImmutableArray<Entity> entities) {
	if (entities == null || entities.size() == 0)
		return null;
	
	Entity targetEntity = entities.first();
	float targetDist = MyMath.distance(position, Mappers.transform.get(targetEntity).pos);
	for (Entity searchEnt : entities) {
		float dist = MyMath.distance(Mappers.transform.get(searchEnt).pos, position);
		if (dist < targetDist) {
			targetDist = dist;
			targetEntity = searchEnt;
		}
	}

	return targetEntity;
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public void printUserData() {
    Family market = Family.all(MarketItemComponent.class, PriceComponent.class, NameComponent.class, PriceHistoryComponent.class).get();
    ImmutableArray<Entity> marketItemEntities = entityEngine.getEntitiesFor(market);

    Family players = Family.all(WalletComponent.class, NameComponent.class, InventoryComponent.class).get();
    for (Entity player : entityEngine.getEntitiesFor(players)) {
        NameComponent nc = player.getComponent(NameComponent.class);
        WalletComponent wc = player.getComponent(WalletComponent.class);
        InventoryComponent ic = player.getComponent(InventoryComponent.class);
        System.out.println("Name: " + nc.name);
        ic.printInventory(marketItemEntities);
        long value = ic.getInventoryValue(marketItemEntities);
        System.out.println("Inventory Value: $" + value);
        System.out.println(" Wallet Balance: $" + wc.balance);
        System.out.println("    Total Value: $" + (value + wc.balance));
    }
}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public void printMarketHistory() {
    Family market = Family.all(MarketItemComponent.class, PriceComponent.class, NameComponent.class, PriceHistoryComponent.class).get();
    ImmutableArray<Entity> entities = entityEngine.getEntitiesFor(market);

    System.out.println("Current Prices: ");
    for (Entity e : entities) {
        PriceComponent p = e.getComponent(PriceComponent.class);
        NameComponent n = e.getComponent(NameComponent.class);
        PriceHistoryComponent history = e.getComponent(PriceHistoryComponent.class);

        Iterator itr;

        System.out.print(n.name + " Resolution 1 \n");
        itr = history.getPriceHistory().iterator();
        while (itr.hasNext()) System.out.print((Integer) itr.next() + "\n");
        System.out.print(n.name + " Resolution 5\n");
        itr = history.getPriceHistorySkipFive().iterator();
        while (itr.hasNext()) System.out.print((Integer) itr.next() + "\n");

        System.out.print(n.name + " Resolution 15\n");
        itr = history.getPriceHistorySkipFifteen().iterator();
        while (itr.hasNext()) System.out.print((Integer) itr.next() + "\n");

    }

}
 

import com.badlogic.ashley.utils.ImmutableArray; //导入依赖的package包/类
public String saveToJson() {
    gameState.stopThread();
    try {
        ImmutableArray<Entity> entities = gameState.getEntityEngine().getEntities();
        SavedGame savedGame = new SavedGame();
        for (Entity entity : entities) {
            List<ComponentContainer> componentContainers = new ArrayList<ComponentContainer>();
            for (Component c : entity.getComponents()) {
                componentContainers.add(new ComponentContainer(c));
            }
            EntityContainer entityContainer = new EntityContainer(entity.getId(), entity.getClass().getName(), componentContainers);
            savedGame.entitiesContainers.add(entityContainer);

        }

        return new GsonBuilder().enableComplexMapKeySerialization().create().toJson(savedGame);
    } catch (Exception e) {
        e.printStackTrace();
    }
    gameState.startThread();
    return "Failed";
}