MobList.java

package com.osroyale.game.world.entity;
 
import com.osroyale.game.world.entity.mob.Mob;
import com.osroyale.util.RandomUtils;
 
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
 
import static com.google.common.base.Preconditions.*;

public final class MobList<E extends Mob> implements Iterable<E> {

    public static final class EntityListIterator<E extends Mob> implements Iterator<E> {

        private final MobList<E> list;

        private int curr;

        private int prev = -1;

        EntityListIterator(MobList<E> list) {
            this.list = list;
        }
 
        @Override
        public boolean hasNext() {
            return curr < list.capacity() && skipNullIndexes();
        }
 
        @Override
        public E next() {
            skipNullIndexes();
            checkPositionIndex(curr, list.capacity(), "No elements left");
            E entity = list.element(curr);
            prev = curr++;
            return entity;
        }
 
        @Override
        public void remove() {
            checkState(prev != -1, "remove() can only be called once after each call to next()");
 
            list.remove(list.get(prev));
            prev = -1;
        }

        private boolean skipNullIndexes() {
            while (list.get(curr) == null) {
                if (++curr >= list.capacity()) {
                    return false;
                }
            }
            return true;
        }
    }

    private final E[] entities;

    private final TreeSet<Integer> indices;

    private int size;

    private int largestIndex;

    @SuppressWarnings("unchecked")
    public MobList(int capacity) {
        entities = (E[]) new Mob[++capacity];
        Stream<Integer> indexStream = IntStream.rangeClosed(1, capacity).boxed();
        indices = new TreeSet<>(indexStream.collect(Collectors.toList()));
    }
 
    @Override
    public Iterator<E> iterator() {
        return new EntityListIterator<>(this);
    }

    public void shuffle() {
        if (size < 2) {
            return;
        }
 
        for (int index = largestIndex; index > 1; index--) {
            int first = index - 1;
            int second = RandomUtils.inclusive(1, index);
            if (first == second) continue;
 
            E tmp = entities[first];
            entities[first] = entities[second];
            entities[second] = tmp;
 
            if (entities[first] != null) {
                entities[first].setListIndex(first);
            }
 
            if (entities[second] != null) {
                entities[second].setListIndex(second);
            }
 
        }
    }

    @Override
    public void forEach(Consumer<? super E> action) {
        int index = 0;
        for (E e : entities) {
            if (e == null) continue;
            action.accept(e);
            if (++index >= size) return;
        }
    }

    public Optional<E> findFirst(Predicate<? super E> filter) {
        for (E e : this) {
            if (filter.test(e)) {
                return Optional.of(e);
            }
        }
        return Optional.empty();
    }

    public Optional<E> findLast(Predicate<? super E> filter) {
        for (int index = capacity(); index > 1; index--) {
            E entity = entities[index];
            if (entity == null) {
                continue;
            }
            if (filter.test(entity)) {
                return Optional.of(entity);
            }
        }
        return Optional.empty();
    }

    public List<E> findAll(Predicate<? super E> filter) {
        List<E> list = new ArrayList<>();
        for (E e : this) {
            if (filter.test(e)) {
                list.add(e);
            }
        }
        return list;
    }

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(entities, Spliterator.ORDERED | Spliterator.DISTINCT);
    }

    public boolean add(E entity) {
        Integer index = indices.pollFirst();
 
        if (index == null || index == capacity()) {
            return false;
        }
 
        if (index > largestIndex) {
            largestIndex = index;
        }
 
        entities[index] = entity;
        entity.setIndex(index);
        entity.setListIndex(index);
        size++;
        return true;
    }

    public boolean remove(E entity) {
        checkArgument(entity.getListIndex() != -1, "index == -1");
        indices.add(entity.getListIndex());
        entities[entity.getListIndex()] = null;
        size--;
        return true;
    }

    public void remove(int index) {
        remove(entities[index]);
    }

    public E get(int index) {
        return entities[index];
    }

    public E element(int index) {
        E entity = get(index);
        checkArgument(entity != null, "index -> null EntityNode");
        return entity;
    }

    public boolean contains(E entity) {
        return entity != null && entity.equals(get(entity.getListIndex()));
    }

    public boolean isFull() {
        return size() == capacity();
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public int size() {
        return size;
    }

    public int remaining() {
        return capacity() - size();
    }

    public int capacity() {
        return entities.length;
    }

    public E[] toArray() {
        return Arrays.copyOf(entities, entities.length);
    }

    public void clear() {
        forEach(this::remove);
    }

    public Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false).filter(Objects::nonNull);
    }

    public Stream<E> parallelStream() {
        Spliterator<E> split = Spliterators.spliterator(entities, spliterator().characteristics() | Spliterator.IMMUTABLE);
        return StreamSupport.stream(split, true).filter(Objects::nonNull);
    }
}