tcr/java/src/game/command/EntityListParser.java

package game.command;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import game.collect.Lists;
import game.collect.Sets;
import game.entity.Entity;
import game.entity.EntityType;
import game.entity.types.EntityLiving;
import game.init.EntityRegistry;
import game.network.Player;
import game.world.WorldServer;

public class EntityListParser extends EntityParser {
	public EntityListParser(String name, boolean useSender, boolean livingOnly) {
		super(name, useSender, livingOnly);
	}

	public Object parse(CommandEnvironment env, String input) {
		if(input.equals("**")) {
			List<Entity> list = Lists.newArrayList();
			for(WorldServer world : env.getServer().getWorlds()) {
				if(this.livingOnly) {
					for(Entity ent : world.getEntities()) {
						if(ent instanceof EntityLiving)
							list.add(ent);
					}
				}
				else {
					list.addAll(world.getEntities());
				}
			}
			if(list.isEmpty())
				throw new RunException(this.livingOnly ? "Keine lebendigen Objekte gefunden" : "Keine Objekte gefunden");
			return list;
		}
		else if(input.equals("*")) {
			List<Entity> list = Lists.newArrayList();
			for(Player plr : env.getServer().getPlayers()) {
				if(plr.getEntity() != null)
					list.add(plr.getEntity());
			}
			if(list.isEmpty())
				throw new RunException("Keine Spieler gefunden");
			return list;
		}
		Set<Class<? extends Entity>> classes = Sets.newHashSet();
		Set<EntityType> types = Sets.newHashSet();
		Set<Entity> entities = Sets.newHashSet();
		Set<Class<? extends Entity>> nclasses = Sets.newHashSet();
		Set<EntityType> ntypes = Sets.newHashSet();
		Set<Entity> nentities = Sets.newHashSet();
		Boolean living = null;
		Boolean player = null;
		for(String tok : input.split(",", -1)) {
			boolean negate = tok.startsWith("!");
			tok = negate ? tok.substring(1) : tok;
			Class<? extends Entity> clazz = EntityRegistry.getEntityClass(tok);
			if(clazz != null) {
				if(classes.contains(clazz) || nclasses.contains(clazz))
					throw new RunException("Objekttyp %s mehrfach angegeben", EntityRegistry.getEntityName(EntityRegistry.getEntityString(clazz)));
				if(this.livingOnly && !EntityLiving.class.isAssignableFrom(clazz))
					throw new RunException("Objekttyp %s ist nicht lebendig", EntityRegistry.getEntityName(EntityRegistry.getEntityString(clazz)));
				(negate ? nclasses : classes).add(clazz);
			}
			else if(tok.equals("Player")) {
				if(player != null)
					throw new RunException("'Player' mehrfach angegeben");
				player = !negate;
			}
			else if(tok.equals("Living")) {
				if(living != null)
					throw new RunException("'Living' mehrfach angegeben");
				if(this.livingOnly)
					throw new RunException("Kann nicht 'Living' als Objekttypen angeben");
				living = !negate;
			}
			else {
				EntityType type = EntityType.getByName(tok);
				if(type != null) {
					if(types.contains(type) || ntypes.contains(type))
						throw new RunException("Objekttyp %s mehrfach angegeben", type.getDisplay());
					(negate ? ntypes : types).add(type);
				}
				else {
					Entity ent = (Entity)super.parse(env, tok);
					if(entities.contains(ent) || nentities.contains(ent))
						throw new RunException("Objekt '%s' mehrfach angegeben", tok);
					(negate ? nentities : entities).add(ent);
				}
			}
		}
		List<Entity> filtered = Lists.newArrayList(entities);
		boolean negateOnly = (living == null && player == null && types.isEmpty() && classes.isEmpty() && entities.isEmpty());
		for(WorldServer world : env.getServer().getWorlds()) {
			for(Entity ent : world.getEntities()) {
				if((!this.livingOnly || ent instanceof EntityLiving) && 
						(negateOnly || (living != null && types.isEmpty() && classes.isEmpty() && living == (ent instanceof EntityLiving)) || (player != null && types.isEmpty() && classes.isEmpty() && player == ent.isPlayer()) || types.contains(ent.getType()) || 
						classes.contains(ent.getClass())) && 
						(living == null || living == (ent instanceof EntityLiving)) && (player == null || player == ent.isPlayer()) && 
						!ntypes.contains(ent.getType()) && !nclasses.contains(ent.getClass()) && !nentities.contains(ent) && !entities.contains(ent))
					filtered.add(ent);
			}
		}
		if(filtered.isEmpty())
			throw new RunException("Keine Objekte gefunden");
		return filtered;
	}
	
	public Object getDefault(CommandEnvironment env) {
		Entity entity = (Entity)super.getDefault(env);
		return entity == null ? null : Lists.newArrayList(entity);
	}
	
	public Collection<String> getCompletions(CommandEnvironment env) {
		Collection<String> comp = super.getCompletions(env);
		comp.add("*");
		for(Class<? extends Entity> clazz : EntityRegistry.getAllClasses()) {
			if(!this.livingOnly || EntityLiving.class.isAssignableFrom(clazz))
				comp.add(EntityRegistry.getEntityString(clazz));
		}
		for(EntityType type : EntityType.values()) {
			comp.add(type.getName());
		}
		Collections.addAll(comp, "Player", "Living", "**");
		return comp;
	}

	public Class<?> getTypeClass() {
		return List.class;
	}
}