Java IntBag类代码示例

import com.artemis.utils.IntBag; //导入依赖的package包/类
public void killCheapestUnit() {

        int productivity = 999;
        int cheapestId=-1;

        IntBag actives = subscription.getEntities();
        int[] ids = actives.getData();
        for (int i = 0, s = actives.size(); s > i; i++) {
            int entity = ids[i];
            Minion minion = mMinion.get(entity);
            if ( minion.productivity < productivity && !mSchedule.has(entity) )
            {
                productivity = minion.productivity;
                cheapestId = entity;
            }
        }

        if ( cheapestId != -1 )
        {
            explode(cheapestId);
        }
    }
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
@Override
public void dispose() {
    physicsInitialized = false;

    IntBag entityIds = getEntityIds();
    for (int entity : entityIds.getData()) {
        RigidBodyComponent bodyComponent = rigidBodyMapper.get(entity);

        if (bodyComponent != null) {
            bodyComponent.dispose();
        }
    }

    dynamicsWorld.dispose();
    constraintSolver.dispose();
    collisionConfiguration.dispose();
    collisionDispatcher.dispose();
    dbvtBroadphase.dispose();
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * toggles highlighted state of actor that is on the same tile as the mouse is
 * over
 */
private boolean toggleHighlightedActors() {
	boolean toggled = false;
	@SuppressWarnings("unchecked")
	final EntitySubscription entitySubscription = GameEngine.getInstance().getAspectSubscriptionManager()
			.get(Aspect.all(PositionComponent.class, HighlightAbleComponent.class)
					.exclude(CursorComponent.class));
	final IntBag entities = entitySubscription.getEntities();
	PositionComponent positionComponent;
	HighlightAbleComponent highlight;
	for (int i = 0; i < entities.size(); i++) {
		positionComponent = ComponentMappers.getInstance().position.get(i);
		if (positionComponent.getX() == mouseOverX && positionComponent.getY() == mouseOverY) {
			highlight = ComponentMappers.getInstance().highlight.get(i);
			highlight.toggleHighlighted();
			toggled = true;
		}
	}
	return toggled;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * checks if all entities have their turn taken for the current turn
 *
 * @param _currentTurnSide
 */
private void processTurnTaken() {
	if (checkReadyToSwitchTurns()) {
		// reset turn components
		final IntBag entities = getAspectSubscriptionManager().get(Aspect.all(TurnComponent.class))
				.getEntities();
		TurnComponent turnComponent;
		for (int i = 0; i < entities.size(); i++) {
			turnComponent = ComponentMappers.getInstance().turn.get(entities.get(i));
			if (turnComponent.getMovesOnTurn() == currentTurnSide) {
				turnComponent.setTurnTaken(false);
				turnComponent.setProcessed(false);
			}
		}
		// switch sides
		currentTurnSide = currentTurnSide == ETurnType.PLAYER ? ETurnType.MONSTER : ETurnType.PLAYER;
		Gdx.app.debug("GameEngine", "switching turn sides to " + ETurnType.toString(currentTurnSide));
	}
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Returns all entities in the specified cells.
 *
 * @param cells set of packed coordinates of entities
 * @return
 */
public IntBag getEntities(final LongBag cells)
{
    final IntBag entities = new IntBag(8);

    final int[] coords = new int[2];

    for (int i = 0, size = cells.size(); i < size; i++)
    {
        final long pos = cells.get(i);

        Coords.unpackCoords(pos, coords);

        final int id = grid[coords[0]][coords[1]];

        if (id >= 0)
            entities.add(id);
    }

    return entities;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
@Override
public void display(final AsciiPanel terminal)
{
    final int playerId = pManager.getEntitiesOfPlayer("player").get(0).getId();

    terminal.clear(' ');

    drawHeader(terminal);

    final Inventory inv = mInventory.get(playerId);

    final ArrayList<String> elements = new ArrayList<>();
    final IntBag            items    = inv.items;
    for (int i = 0, size = items.size(); i < size; i++)
    {
        final int itemId = items.get(i);

        if (!canDraw(itemId))
            continue;

        elements
            .add(String.format("%s %s", mName.get(itemId).name.toLowerCase(), mEquip.has(itemId) ? " [WORN]" : ""));
    }

    drawList(terminal, elements);
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Creates a new, empty group.
 *
 * @return the id of the group
 */
public int createGroup()
{
    final IntBag newGroup = new IntBag(5);

    final int newId;
    if (recycling.isEmpty())
    {
        newId = groups.size();
    }
    else
    {
        newId = recycling.popFirst();
    }

    groups.set(newId, newGroup);

    return newId;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Unsubscribe T from entity.
 *
 * @param subscriber subscriber
 * @param entityId   entity to subscribe
 */
public void unsubscribe(T subscriber, int entityId) {

    // unhook entity from subscriber
    IntBag entities = subscriberEntities.get(subscriber);
    if (entities != null) {
        int index = entities.indexOf(entityId);
        if ( index != -1 ) {
            entities.remove(index);
        }
    }

    // unhook subscriber from entity.
    Bag<T> subscribers = entitySubscribers.get(entityId);
    if (subscribers != null) {
        subscribers.remove(subscriber);
    }
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Returns entity ids of entities that bounds contain given point
 */
public IntBag getExact (IntBag fill, float x, float y) {
	if (bounds.contains(x, y)) {
		if (nodes[0] != null) {
			int index = indexOf(x, y, 0, 0);
			if (index != OUTSIDE) {
				nodes[index].getExact(fill, x, y, 0, 0);
			}
		}
		for (int i = 0; i < containers.size(); i++) {
			Container c = containers.get(i);
			if (c.contains(x, y)) {
				fill.add(c.eid);
			}
		}
	}
	return fill;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Returns entity ids of entities that are inside {@link QuadTree}s that overlap given bounds
 *
 * Returned entities must be filtered further as these results are not exact
 */
public IntBag get (IntBag fill, float x, float y, float width, float height) {
	if (bounds.overlaps(x, y, width, height)) {
		if (nodes[0] != null) {
			int index = indexOf(x, y, width, height);
			if (index != OUTSIDE) {
				nodes[index].get(fill, x, y, width, height);
			} else {
				// if test bounds don't fully fit inside a node, we need to check them all
				for (int i = 0; i < nodes.length; i++) {
					nodes[i].get(fill, x, y, width, height);
				}
			}
		}
		for (int i = 0; i < containers.size(); i++) {
			Container c = containers.get(i);
			fill.add(c.eid);
		}
	}
	return fill;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
@Override
protected void processSystem() {

    final IntBag entities = subscription.getEntities();

    final int processedPerSecond = (int) ((entities.size() / getRoundTripTime()));

    // Depending on subscription size invocation could potentially require less than
    // one invocation. Keep track of 'partial' invocations until we can invoke.
    entitiesToProcess += processedPerSecond * getWorldDelta();
    if (entitiesToProcess >= 1f) {
        processEntities((int) entitiesToProcess, entities.getData(), entities.size());

        // keep remainder.
        entitiesToProcess -= (int) entitiesToProcess;
    }
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
/**
 * Iterate over all entities.
 *
 * Stop when allotted time has passed.
 * Stop when all entities have been cycled.
 */
@Override
protected final void processSystem() {

	final IntBag actives = subscription.getEntities();
	final int[] array = actives.getData();

	final int size = actives.size();
	int processed = 0;
	if ( size > 0 ) {

		long time = getTime();
		final long deadline = time + (long) (getAllottedTime() * MILLISECONDS_PER_SECOND);

		index = index % size; // avoid breakage upon subscription changes.
		while ((processed < size) && (time < deadline)) {
			lastProcessedEntityId = array[index];
			process(lastProcessedEntityId);
			index = ++index % size;
			processed++;
			time = getTime();
		}
	}
	processedEntities = processed;
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
@Test
public void complex_get_test() {
	IntBag fill = new IntBag();
	QuadTree.MAX_IN_BUCKET = 1;
	QuadTree tree = new QuadTree(-8, -8, 8, 8);
	fill.clear();
	tree.get(fill, -3, -3, 6, 6);
	Assert.assertEquals(fill.size(), 0);

	// all outside
	tree.insert(1, -6, -6, 2, 2);
	tree.insert(2,  4, -6, 2, 2);
	tree.insert(3, -6,  4, 2, 2);
	tree.insert(4,  4,  4, 2, 2);

	tree.insert(5, -1, -1, 2, 2); // cemter
	tree.insert(6, -4, -4, 2, 2); // fully inside
	tree.insert(7,  2,  2, 2, 2); // fully inside
	tree.insert(8, -4, -4, 2, 2); // fully inside

}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
public void reloadFonts (boolean reloadBmpFonts, boolean reloadTtfFonts) {
	IntBag bag = subscription.getEntities();
	int[] data = bag.getData();

	for (int i = 0; i < bag.size(); i++) {
		int id = data[i];
		Entity entity = world.getEntity(id);

		VisText text = textCm.get(entity);
		VisAssetDescriptor asset = assetCm.get(entity).asset;

		if (asset instanceof BmpFontAsset && reloadBmpFonts)
			text.setFont(fontCache.get((BmpFontAsset) asset, pixelInUnits));

		if (asset instanceof TtfFontAsset && reloadTtfFonts)
			text.setFont(fontCache.get((TtfFontAsset) asset, pixelInUnits));
	}
}
 

import com.artemis.utils.IntBag; //导入依赖的package包/类
public void reloadTextures () {
	IntBag bag = subscription.getEntities();
	int[] data = bag.getData();

	for (int i = 0; i < bag.size(); i++) {
		int id = data[i];
		Entity entity = world.getEntity(id);

		VisSprite sprite = spriteCm.get(entity);
		VisAssetDescriptor asset = assetCm.get(entity).asset;

		boolean flipX = sprite.isFlipX();
		boolean flipY = sprite.isFlipY();
		sprite.setRegion(textureCache.getRegion(asset));
		sprite.setFlip(flipX, flipY);
	}
}