/** Safely delete all entities from bag, regardless if the bag changes. */ public static void safeDeleteAll(final ImmutableBag<Entity> entities1) { final Bag<Entity> entities = new Bag<>(); entities.addAll(entities1); for (int i = 0, s = entities.size(); i < s; i++) { entities.get(i).deleteFromWorld(); } } }
@Override public void validate(int sourceId, Bag<Entity> entities, LinkListener listener) { for (int i = 0; entities.size() > i; i++) { Entity e = entities.get(i); if (!all.getActiveEntityIds().unsafeGet(e.getId())) { entities.remove(i--); if (listener != null) listener.onTargetDead(sourceId, e.getId()); } } }
/** Fetch unique identity for passed composition. */ int getIdentity(BitVector components) { Object[] bitsets = compositionBits.getData(); int size = compositionBits.size(); for (int i = NO_COMPONENTS; size > i; i++) { // want to start from 1 so that 0 can mean null if (components.equals(bitsets[i])) return i; } return -1; }
int allocateIdentity(BitVector componentBits, ComponentManager cm) { Bag<ComponentMapper> mappers = new Bag<ComponentMapper>(ComponentMapper.class, componentBits.cardinality()); ComponentTypeFactory tf = cm.getTypeFactory(); for (int i = componentBits.nextSetBit(0); i >= 0; i = componentBits.nextSetBit(i + 1)) { mappers.add(cm.getMapper(tf.getTypeFor(i).getType())); } compositionMappers.add(mappers); compositionBits.add(new BitVector(componentBits)); return compositionBits.size() - 1; } }
@Override public void process() { Object[] eventsToDispatch = eventQueue.getData(); int i = 0; int s = eventQueue.size(); while (i < s) { for (; i < s; i++) { Event event = (Event) eventsToDispatch[i]; super.dispatch(event); } // we may end up having more events to dispatch at this point // - some event handlers could dispatch more events s = eventQueue.size(); } eventQueue.clear(); }
void translate(Component c, Field field, Bag<Entity> translatedIds) { try { Bag bag = (Bag) field.get(c); for (int i = 0, s = bag.size(); s > i; i++) { Object o = bag.get(i); if (o instanceof Entity) { bag.set(i, translatedIds.get(((Entity)o).getId())); } else { return; } } } catch (ReflectionException e) { throw new RuntimeException(e); } } };
/** * Add listener interested in changes to the subscription. * * @param listener listener to add. */ public void addSubscriptionListener(SubscriptionListener listener) { extra.listeners.add(listener); }
private void growEntityStores() { int newSize = 2 * entities.getCapacity(); entities.ensureCapacity(newSize); ComponentManager cm = world.getComponentManager(); cm.ensureCapacity(newSize); for (int i = 0, s = entityBitVectors.size(); s > i; i++) { entityBitVectors.get(i).ensureCapacity(newSize); } }
public ArchetypeMapper(World world, IntBag toSave) { int[] ids = toSave.getData(); Bag<Component> components = new Bag<Component>(); Bag<Class<? extends Component>> types = new Bag<Class<? extends Component>>(); for (int i = 0, s = toSave.size(); s > i; i++) { int compositionId = world.getEntity(ids[i]).getCompositionId(); if (!compositionIdMapper.containsKey(compositionId)) { components.clear(); types.clear(); world.getComponentManager().getComponentsFor(ids[i], components); compositionIdMapper.put(compositionId, new TransmuterEntry(toClasses(components, types))); } } }
/** * Gets component type by index. * <p> * @param index maps to {@link ComponentType} * @return the component's {@link ComponentType} */ public ComponentType getTypeFor(int index) { return types.get(index); }
/** * Get listeners for class, including all superclasses, * sorted by priority. * * Not backed by cache. * * @param aClass Class to fetch listeners for. * @return Bag of listeners, empty if none found. */ private Bag<EventListener> getListenersForHierarchicalUncached(Class<?> aClass) { // get hierarchy for event. final Class<?>[] classes = classHierarchy.of(aClass); // step through hierarchy back to front, fetching the listeners for each step. final Bag<EventListener> hierarchicalListeners = new Bag<>(4); for (Class<?> c : classes) { final Bag<EventListener> listeners = getListenersFor(c, false); if (listeners != null) { hierarchicalListeners.addAll(listeners); } } // sort by priority. BagUtils.sort(hierarchicalListeners); return hierarchicalListeners; }
/** * Clears entire pool. */ public void clear() { pool.clear(); }