HubMissionWithSearch.java

Go to the documentation of this file.

package com.fs.starfarer.api.impl.campaign.missions.hub;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
 
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.campaign.AsteroidAPI;
import com.fs.starfarer.api.campaign.CampaignTerrainAPI;
import com.fs.starfarer.api.campaign.LocationAPI;
import com.fs.starfarer.api.campaign.PlanetAPI;
import com.fs.starfarer.api.campaign.SectorEntityToken;
import com.fs.starfarer.api.campaign.StarSystemAPI;
import com.fs.starfarer.api.campaign.econ.CommodityOnMarketAPI;
import com.fs.starfarer.api.campaign.econ.Industry;
import com.fs.starfarer.api.campaign.econ.MarketAPI;
import com.fs.starfarer.api.campaign.econ.MarketAPI.SurveyLevel;
import com.fs.starfarer.api.campaign.econ.MarketConditionAPI;
import com.fs.starfarer.api.characters.PersonAPI;
import com.fs.starfarer.api.impl.campaign.DebugFlags;
import com.fs.starfarer.api.impl.campaign.econ.CommodityIconCounts;
import com.fs.starfarer.api.impl.campaign.ids.Conditions;
import com.fs.starfarer.api.impl.campaign.ids.Factions;
import com.fs.starfarer.api.impl.campaign.ids.MemFlags;
import com.fs.starfarer.api.impl.campaign.ids.Tags;
import com.fs.starfarer.api.impl.campaign.rulecmd.salvage.MarketCMD;
import com.fs.starfarer.api.impl.campaign.terrain.BaseRingTerrain;
import com.fs.starfarer.api.impl.campaign.terrain.BaseTiledTerrain;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.util.WeightedRandomPicker;
 
public abstract class HubMissionWithSearch extends HubMissionWithTriggers {
 
//  /**
//   * "Center of mass".
//   * @return
//   */
//  public Vector2f getApproximateLocationOfOtherMissions() {
//      Vector2f com = new Vector2f();
//      
//      PersonAPI person = getPerson();
//      MarketAPI market = null;
//      if (person != null) market = person.getMarket();
//      
//      Vector2f playerLoc = Global.getSector().getPlayerFleet().getLocationInHyperspace();
//      float thresholdDistForBonusAngle = 8000f;
//      
//      float count = 0f;
//      for (BaseHubMission curr : BaseMissionHub.getCreatedMissionsList(person, market)) {
//          if (curr.getStartingStage() == null) continue;
//          SectorEntityToken loc = curr.getMapLocation(null, curr.getStartingStage());
//          if (loc == null) continue;
//          
//          // closer locations are weighed a lot less since they can really swing the angle a lot
//          float f = 1f;
//          float dist = Misc.getDistance(playerLoc, loc.getLocationInHyperspace());
//          if (dist < thresholdDistForBonusAngle) {
//              f = dist / thresholdDistForBonusAngle;
//              f *= f;
//          }
//          
//          // rather, actually, just skip the closer locations
//          if (f < 1f) continue;
//          
//          Vector2f add = new Vector2f(loc.getLocationInHyperspace());
//          add.scale(f);
//          Vector2f.add(com, add, com);
//          count += f;
//      }
//      if (count > 0) {
//          com.scale(1f / count);
//      }
//      return com;
//  }
    
    public boolean matchesSetMissionAngle(Vector2f other, float allowedArc, 
                                                      float allowedArcBonusIfClose) {
        Vector2f playerLoc = Global.getSector().getPlayerFleet().getLocationInHyperspace();
        
        PersonAPI person = getPerson();
        MarketAPI market = null;
        if (person != null) market = person.getMarket();
        
        float missionAngle = BaseMissionHub.getMissionAngle(person, market);
        
        float angleToOther = Misc.getAngleInDegrees(playerLoc, other); 
        float distToOther = Misc.getDistance(playerLoc, other); 
        
        float angleDiff = Misc.getAngleDiff(missionAngle, angleToOther);
        
        float maxAllowedAngleDiff = allowedArc / 2f;
        float thresholdDistForBonusAngle = 5000f;
        if (distToOther < thresholdDistForBonusAngle) {
            float f = (1f - distToOther / thresholdDistForBonusAngle);
            //f *= f;
            maxAllowedAngleDiff += f * allowedArcBonusIfClose / 2f;
        }
        return angleDiff <= maxAllowedAngleDiff;
    }
    
    public static float DEFAULT_MISSION_ARC = 60f;
    public static float DEFAULT_MISSION_ARC_BONUS = 90f;
    public static float DEFAULT_MISSION_MARKET_ARC = 150f;
    public static float DEFAULT_MISSION_MARKET_ARC_BONUS = 210f;
    
    public static class SystemInDirectionOfOtherMissionsReq implements StarSystemRequirement {
        protected HubMissionWithSearch mission;
        protected float arcMult;
        public SystemInDirectionOfOtherMissionsReq(HubMissionWithSearch mission, float arcMult) {
            this.mission = mission;
            this.arcMult = arcMult;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            return mission.matchesSetMissionAngle(system.getLocation(), 
                    DEFAULT_MISSION_ARC * arcMult, 90f);
        }
    }
    
    public static class MarketInDirectionOfOtherMissionsReq implements MarketRequirement {
        protected HubMissionWithSearch mission;
        protected float arcMult;
        public MarketInDirectionOfOtherMissionsReq(HubMissionWithSearch mission, float arcMult) {
            this.mission = mission;
            this.arcMult = arcMult;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            return mission.matchesSetMissionAngle(market.getLocationInHyperspace(), 
                        DEFAULT_MISSION_MARKET_ARC * arcMult, DEFAULT_MISSION_MARKET_ARC_BONUS);
        }
    }
    
    public static class PlanetInDirectionOfOtherMissionsReq implements PlanetRequirement {
        protected HubMissionWithSearch mission;
        protected float arcMult;
        public PlanetInDirectionOfOtherMissionsReq(HubMissionWithSearch mission, float arcMult) {
            this.mission = mission;
            this.arcMult = arcMult;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
//          if (planet.getStarSystem().getNameWithNoType().toLowerCase().equals("megaron")) {
//              System.out.println("ewfwefwefwe");
//          }
            return mission.matchesSetMissionAngle(planet.getLocationInHyperspace(), 
                    DEFAULT_MISSION_ARC * arcMult, DEFAULT_MISSION_ARC_BONUS);
        }
    }
    
    public static class EntityInDirectionOfOtherMissionsReq implements EntityRequirement {
        protected HubMissionWithSearch mission;
        protected float arcMult;
        public EntityInDirectionOfOtherMissionsReq(HubMissionWithSearch mission, float arcMult) {
            this.mission = mission;
            this.arcMult = arcMult;
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            return mission.matchesSetMissionAngle(entity.getLocationInHyperspace(),
                    DEFAULT_MISSION_ARC * arcMult, DEFAULT_MISSION_ARC_BONUS);
        }
    }
    
    public static class TerrainInDirectionOfOtherMissionsReq implements TerrainRequirement {
        protected HubMissionWithSearch mission;
        protected float arcMult;
        public TerrainInDirectionOfOtherMissionsReq(HubMissionWithSearch mission, float arcMult) {
            this.mission = mission;
            this.arcMult = arcMult;
        }
        public boolean terrainMatchesRequirement(CampaignTerrainAPI terrain) {
            return mission.matchesSetMissionAngle(terrain.getLocationInHyperspace(),
                    DEFAULT_MISSION_ARC * arcMult, DEFAULT_MISSION_ARC_BONUS);
        }
    }
    
 
    public static class SystemInDirection implements StarSystemRequirement {
        protected float dir;
        protected float arc;
        protected HubMissionWithSearch mission;
        
        public SystemInDirection(HubMissionWithSearch mission, float dir, float arc) {
            this.mission = mission;
            this.dir = dir;
            this.arc = arc;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            if (mission.getPerson() == null) return false;
            if (mission.getPerson().getMarket() == null) return false;
            Vector2f from = mission.getPerson().getMarket().getLocationInHyperspace();
            return Misc.isInArc(dir, arc, from, system.getLocation());
        }
    }
    
    public static class SystemInDirectionFrom implements StarSystemRequirement {
        protected Vector2f from;
        protected float dir;
        protected float arc;
        
        public SystemInDirectionFrom(Vector2f from, float dir, float arc) {
            this.from = from;
            this.dir = dir;
            this.arc = arc;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            return Misc.isInArc(dir, arc, from, system.getLocation());
        }
    }
    
    public static class MarketIsReq implements MarketRequirement {
        boolean negate;
        MarketAPI param;
        public MarketIsReq(MarketAPI param, boolean negate) {
            this.param = param;
            this.negate = negate;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            boolean result = market == param;
            if (negate) result = !result;
            return result;
        }
    }
    public static class MarketFactionReq implements MarketRequirement {
        boolean negate;
        Set<String> factions;
        public MarketFactionReq(boolean negate, String ... factions) {
            this.factions = new LinkedHashSet<String>();
            this.factions.addAll(Arrays.asList(factions));
            this.negate = negate;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            boolean result = factions.contains(market.getFactionId());
            if (negate) result = !result;
            return result;
        }
    }
    
    public static class MarketTacticalBombardableReq implements MarketRequirement {
        boolean negate;
        public MarketTacticalBombardableReq(boolean negate) {
            this.negate = negate;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            boolean result = !MarketCMD.getTacticalBombardmentTargets(market).isEmpty();
            if (negate) result = !result;
            return result;
        }
    }
    
    public static class MarketFactionHostileReq implements MarketRequirement {
        boolean negate;
        String faction;
        public MarketFactionHostileReq(boolean negate, String faction) {
            this.faction = faction;
            this.negate = negate;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            boolean result = market.getFaction().isHostileTo(faction);
            if (negate) result = !result;
            return result;
        }
    }
//  public static class MarketFactionCustomFlagReq implements MarketRequirement {
//      boolean negate;
//      String flag;
//      public MarketFactionCustomFlagReq(boolean negate, String flag) {
//          this.flag = flag;
//          this.negate = negate;
//      }
//      public boolean marketMatchesRequirement(MarketAPI market) {
//          boolean result = market.getFaction().getCustomBoolean(flag);
//          if (negate) result = !result;
//          return result;
//      }
//  }
    
    public static class MarketMilitaryReq implements MarketRequirement {
        public boolean marketMatchesRequirement(MarketAPI market) {
            return Misc.isMilitary(market);
        }
    }
    public static class MarketNotMilitaryReq implements MarketRequirement {
        public boolean marketMatchesRequirement(MarketAPI market) {
            return !Misc.isMilitary(market);
        }
    }
    
    public static class MarketHiddenReq implements MarketRequirement {
        public boolean marketMatchesRequirement(MarketAPI market) {
            return market.isHidden();
        }
    }
    public static class MarketNotHiddenReq implements MarketRequirement {
        public boolean marketMatchesRequirement(MarketAPI market) {
            return !market.isHidden();
            //return !market.isHidden() && !market.isInvalidMissionTarget();
        }
    }
    public static class MarketNotInHyperReq implements MarketRequirement {
        public boolean marketMatchesRequirement(MarketAPI market) {
            return !market.isInHyperspace();
        }
    }
    
    public static class MarketMemoryFlagReq implements MarketRequirement {
        String key;
        Object value;
        public MarketMemoryFlagReq(String key, Object value) {
            this.key = key;
            this.value = value;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            Object val = market.getMemoryWithoutUpdate().get(key);
            return val != null && val.equals(value);
        }
    }
    
    public static class MarketLocationReq implements MarketRequirement {
        boolean negate;
        Set<LocationAPI> locations;
        public MarketLocationReq(boolean negate, LocationAPI ... locations) {
            this.locations = new LinkedHashSet<LocationAPI>();
            this.locations.addAll(Arrays.asList(locations));
            this.negate = negate;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            boolean result = locations.contains(market.getContainingLocation());
            if (negate) result = !result;
            return result;
        }
    }
    public static class MarketFactionCustomReq extends StringCollectionReqs implements MarketRequirement {
        public MarketFactionCustomReq(ReqMode mode, String ... custom) {
            super(mode, custom);
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            Set<String> set = new HashSet<String>();
            for (String custom : tags) {
                if (market.getFaction().getCustomBoolean(custom)) {
                    set.add(custom);
                }
            }
            return matchesRequirements(set);
        }
    }
    
    public static interface GenericRequirement {
        
    }
    public static interface StarSystemRequirement extends GenericRequirement {
        public boolean systemMatchesRequirement(StarSystemAPI system);
    }
    public static interface PlanetRequirement extends GenericRequirement {
        public boolean planetMatchesRequirement(PlanetAPI planet);
    }
    public static interface EntityRequirement extends GenericRequirement {
        public boolean entityMatchesRequirement(SectorEntityToken entity);
    }
    public static interface MarketRequirement extends GenericRequirement {
        public boolean marketMatchesRequirement(MarketAPI market);
    }
    public static interface CommodityRequirement extends GenericRequirement {
        public boolean commodityMatchesRequirement(CommodityOnMarketAPI com);
    }
    public static interface TerrainRequirement extends GenericRequirement {
        public boolean terrainMatchesRequirement(CampaignTerrainAPI terrain);
    }
    
    public static boolean matchesReq(GenericRequirement req, Object param) {
        if (req instanceof StarSystemRequirement) {
            return ((StarSystemRequirement) req).systemMatchesRequirement((StarSystemAPI) param);
        }
        if (req instanceof PlanetRequirement) {
            return ((PlanetRequirement) req).planetMatchesRequirement((PlanetAPI) param);
        }
        if (req instanceof EntityRequirement) {
            return ((EntityRequirement) req).entityMatchesRequirement((SectorEntityToken) param);
        }
        if (req instanceof MarketRequirement) {
            if (((MarketAPI)param).isInvalidMissionTarget()) return false;
            return ((MarketRequirement) req).marketMatchesRequirement((MarketAPI) param);
        }
        if (req instanceof CommodityRequirement) {
            return ((CommodityRequirement) req).commodityMatchesRequirement((CommodityOnMarketAPI) param);
        }
        if (req instanceof TerrainRequirement) {
            return ((TerrainRequirement) req).terrainMatchesRequirement((CampaignTerrainAPI) param);
        }
        return false;
    }
    
    public static class TerrainTypeReq extends StringCollectionReqs implements TerrainRequirement {
        public TerrainTypeReq(ReqMode mode, String[] types) {
            super(mode, types);
        }
        public boolean terrainMatchesRequirement(CampaignTerrainAPI terrain) {
            Set<String> set = new HashSet<String>();
            set.add(terrain.getType());
            return matchesRequirements(set);
        }
    }
    public static class TerrainHasSpecialNameReq implements TerrainRequirement {
        public TerrainHasSpecialNameReq() {
        }
        public boolean terrainMatchesRequirement(CampaignTerrainAPI terrain) {
            String n1 = terrain.getPlugin().getTerrainName();
            String n2 = terrain.getPlugin().getNameForTooltip();
            if (n1 == null) return false;
            return (!n1.equals(n2));
        }
    }
    public static class EntityUndiscoveredReq implements EntityRequirement {
        boolean negate;
        public EntityUndiscoveredReq(boolean negate) {
            this.negate = negate;
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            boolean result = entity.isDiscoverable();
            if (negate) result = !result;
            return result;
        }
    }
 
    public static class EntityTypeReq implements EntityRequirement {
        private Set<String> set;
        public EntityTypeReq(String[] types) {
            set = new LinkedHashSet<String>();
            for (String type : types) {
                set.add(type);
            }
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            return set.contains(entity.getCustomEntityType());
        }
    }
    
    public static class EntityMemoryReq implements EntityRequirement {
        private List<String> flags = new ArrayList<String>();
        public EntityMemoryReq(String ... flags) {
            for (String flag : flags) {
                this.flags.add(flag);
            }
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            for (String flag : flags) {
                if (!entity.getMemoryWithoutUpdate().getBoolean(flag)) return false;
            }
            return true;
        }
    }
    
    public static class SystemOnFringeOfSectorReq implements StarSystemRequirement {
        protected float rangeLY = Global.getSettings().getFloat("sectorHeight") / Misc.getUnitsPerLightYear() * 
                                        NON_FRINGE_PORTION_OF_HEIGHT * 0.5f;
        protected boolean negate = false;
        public SystemOnFringeOfSectorReq() {
            this(false);
        }
        public SystemOnFringeOfSectorReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = Misc.getDistanceLY(new Vector2f(), system.getLocation()) > rangeLY;
            if (negate) result = !result;
            return result;
        }
    }
    public static class SystemInInnerSectorReq implements StarSystemRequirement {
        protected float rangeLY = Global.getSettings().getFloat("sectorHeight") / Misc.getUnitsPerLightYear() * 
                                        INNER_SECTOR_PORTION_OF_HEIGHT * 0.5f;
        protected boolean negate = false;
        public SystemInInnerSectorReq() {
            this(false);
        }
        public SystemInInnerSectorReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = Misc.getDistanceLY(new Vector2f(), system.getLocation()) < rangeLY;
            if (negate) result = !result;
            return result;
        }
    }
    
    public static class SystemWithinRangeReq implements StarSystemRequirement {
        private Vector2f loc;
        private float minRangeLY;
        private float maxRangeLY;
        public SystemWithinRangeReq(Vector2f loc, float minRangeLY, float maxRangeLY) {
            this.loc = loc;
            this.minRangeLY = minRangeLY;
            this.maxRangeLY = maxRangeLY;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            float dist = Misc.getDistanceLY(loc, system.getLocation());
            return dist >= minRangeLY && dist <= maxRangeLY;
        }
    }
    
    public static class SystemHasBaseReq implements StarSystemRequirement {
        private String factionId;
        public SystemHasBaseReq(String factionId) {
            this.factionId = factionId;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            for (MarketAPI market : Misc.getMarketsInLocation(system)) {
                if (!factionId.equals(market.getFactionId())) continue;
                if (market.getMemoryWithoutUpdate().getBoolean(MemFlags.HIDDEN_BASE_MEM_FLAG)) {
                    return true;
                }
            }
            return false;
        }
    }
    
    public static class SystemHasColonyReq implements StarSystemRequirement {
        private String factionId;
        private int minSize;
        public SystemHasColonyReq(String factionId, int minSize) {
            this.factionId = factionId;
            this.minSize = minSize;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            for (MarketAPI market : Misc.getMarketsInLocation(system)) {
                if (!factionId.equals(market.getFactionId())) continue;
                if (market.getSize() < minSize) continue;
                if (market.getMemoryWithoutUpdate().getBoolean(MemFlags.HIDDEN_BASE_MEM_FLAG)) {
                    continue;
                }
                return true;
            }
            return false;
        }
    }
    
    public static class MultipleStarSystemRequirements implements StarSystemRequirement {
        protected StarSystemRequirement [] reqs;
        protected ReqMode mode;
        public MultipleStarSystemRequirements(ReqMode mode, StarSystemRequirement ... reqs) {
            this.mode = mode;
            this.reqs = reqs;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            switch (mode) {
            case ALL:
                for (StarSystemRequirement req : reqs) if (!req.systemMatchesRequirement(system)) return false;
                return true;
            case ANY:
                for (StarSystemRequirement req : reqs) if (req.systemMatchesRequirement(system)) return true;
                return false;
            case NOT_ALL:
                for (StarSystemRequirement req : reqs) if (!req.systemMatchesRequirement(system)) return true;
                return false;
            case NOT_ANY:
                for (StarSystemRequirement req : reqs) if (req.systemMatchesRequirement(system)) return false;
                return true;
            }
            return false;
        }
    }
    public static class MultiplePlanetRequirements implements PlanetRequirement {
        protected PlanetRequirement [] reqs;
        protected ReqMode mode;
        public MultiplePlanetRequirements(ReqMode mode, PlanetRequirement ... reqs) {
            this.mode = mode;
            this.reqs = reqs;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            switch (mode) {
            case ALL:
                for (PlanetRequirement req : reqs) if (!req.planetMatchesRequirement(planet)) return false;
                return true;
            case ANY:
                for (PlanetRequirement req : reqs) if (req.planetMatchesRequirement(planet)) return true;
                return false;
            case NOT_ALL:
                for (PlanetRequirement req : reqs) if (!req.planetMatchesRequirement(planet)) return true;
                return false;
            case NOT_ANY:
                for (PlanetRequirement req : reqs) if (req.planetMatchesRequirement(planet)) return false;
                return true;
            }
            return false;
        }
    }
    public static class MultipleEntityRequirements implements EntityRequirement {
        protected EntityRequirement [] reqs;
        protected ReqMode mode;
        public MultipleEntityRequirements(ReqMode mode, EntityRequirement ... reqs) {
            this.mode = mode;
            this.reqs = reqs;
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            switch (mode) {
            case ALL:
                for (EntityRequirement req : reqs) if (!req.entityMatchesRequirement(entity)) return false;
                return true;
            case ANY:
                for (EntityRequirement req : reqs) if (req.entityMatchesRequirement(entity)) return true;
                return false;
            case NOT_ALL:
                for (EntityRequirement req : reqs) if (!req.entityMatchesRequirement(entity)) return true;
                return false;
            case NOT_ANY:
                for (EntityRequirement req : reqs) if (req.entityMatchesRequirement(entity)) return false;
                return true;
            }
            return false;
        }
    }
    
    public static class MultipleMarketRequirements implements MarketRequirement {
        protected MarketRequirement [] reqs;
        protected ReqMode mode;
        public MultipleMarketRequirements(ReqMode mode, MarketRequirement ... reqs) {
            this.mode = mode;
            this.reqs = reqs;
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            switch (mode) {
            case ALL:
                for (MarketRequirement req : reqs) if (!req.marketMatchesRequirement(market)) return false;
                return true;
            case ANY:
                for (MarketRequirement req : reqs) if (req.marketMatchesRequirement(market)) return true;
                return false;
            case NOT_ALL:
                for (MarketRequirement req : reqs) if (!req.marketMatchesRequirement(market)) return true;
                return false;
            case NOT_ANY:
                for (MarketRequirement req : reqs) if (req.marketMatchesRequirement(market)) return false;
                return true;
            }
            return false;
        }
    }
    
    public static class MultipleCommodityRequirements implements CommodityRequirement {
        protected CommodityRequirement [] reqs;
        protected ReqMode mode;
        public MultipleCommodityRequirements(ReqMode mode, CommodityRequirement ... reqs) {
            this.mode = mode;
            this.reqs = reqs;
        }
        public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
            switch (mode) {
            case ALL:
                for (CommodityRequirement req : reqs) if (!req.commodityMatchesRequirement(com)) return false;
                return true;
            case ANY:
                for (CommodityRequirement req : reqs) if (req.commodityMatchesRequirement(com)) return true;
                return false;
            case NOT_ALL:
                for (CommodityRequirement req : reqs) if (!req.commodityMatchesRequirement(com)) return true;
                return false;
            case NOT_ANY:
                for (CommodityRequirement req : reqs) if (req.commodityMatchesRequirement(com)) return false;
                return true;
            }
            return false;
        }
    }
    
    
    public static class PlanetOrbitIsNotNearJumpPoint implements PlanetRequirement {
        protected float checkDist;
        public PlanetOrbitIsNotNearJumpPoint(float checkDist) {
            this.checkDist = checkDist;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            StarSystemAPI system = planet.getStarSystem();
            if (system == null) return true;
            
            float planetDist = planet.getCircularOrbitRadius();
            if (planet.getOrbit() == null) {
                planetDist = planet.getLocation().length();
            }
            
            for (SectorEntityToken jp : system.getJumpPoints()) {
                float dist = 0;
                if (jp.getOrbitFocus() == planet.getOrbitFocus()) {
                    float jpDist = jp.getCircularOrbitRadius();
                    if (jp.getOrbitFocus() == null) {
                        jpDist = jp.getLocation().length();
                    }
                    dist = Math.abs(planetDist - jpDist);
                    if (jp.getOrbitFocus() == null && planet.getOrbitFocus() == null) {
                        dist = Misc.getDistance(planet, jp);
                    }
                } else if (jp.getOrbitFocus() == null && planet.getOrbitFocus() != null) {
                    float jpDist = Misc.getDistance(jp, planet.getOrbitFocus());
                    dist = Math.abs(planetDist - jpDist);
                    if (jp.getOrbitFocus() == null && planet.getOrbitFocus() == null) {
                        dist = Misc.getDistance(planet, jp);
                    }
                } else if (jp.getOrbitFocus() != null && planet.getOrbitFocus() == null) {
                    float jpDist = jp.getCircularOrbitRadius();
                    float pDist2 = Misc.getDistance(jp.getOrbitFocus(), jp);
                    dist = Math.abs(pDist2 - jpDist);
                    if (jp.getOrbitFocus() == null && planet.getOrbitFocus() == null) {
                        dist = Misc.getDistance(planet, jp);
                    }
                } else if (jp.getOrbitFocus() != null && planet.getOrbitFocus() != null) {
                    // orbiting different centers
                    float jpDist = jp.getCircularOrbitRadius();
                    dist = Misc.getDistance(jp.getOrbitFocus(), planet.getOrbitFocus());
                    dist -= planetDist + jpDist;
                }
                if (dist < checkDist) return false;
            }
            return true;
        }
    }
    
    public static class PlanetIsPopulatedReq implements PlanetRequirement {
        protected boolean negate = false;
        public PlanetIsPopulatedReq() {
            this(false);
        }
        public PlanetIsPopulatedReq(boolean negate) {
            this.negate = negate;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            boolean result = planet.getMarket() != null && !planet.getMarket().isPlanetConditionMarketOnly();
            if (negate) result = !result;
            return result;
        }
    }
    public static class PlanetUnexploredRuinsReq implements PlanetRequirement {
        protected boolean negate = false;
        public PlanetUnexploredRuinsReq() {
            this(false);
        }
        public PlanetUnexploredRuinsReq(boolean negate) {
            this.negate = negate;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            MarketAPI market = planet.getMarket();
            boolean result = market != null && market.isPlanetConditionMarketOnly() && 
                        !market.getMemoryWithoutUpdate().getBoolean("$ruinsExplored");
            if (negate) result = !result;
            return result;
        }
    }
    public static class PlanetFullySurveyedReq implements PlanetRequirement {
        protected boolean negate = false;
        public PlanetFullySurveyedReq() {
            this(false);
        }
        public PlanetFullySurveyedReq(boolean negate) {
            this.negate = negate;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            boolean result = planet.getMarket() != null && planet.getMarket().getSurveyLevel() == SurveyLevel.FULL;
            if (negate) result = !result;
            return result;
        }
    }
    public static class PlanetUnsurveyedReq implements PlanetRequirement {
        protected boolean negate = false;
        public PlanetUnsurveyedReq() {
            this(false);
        }
        public PlanetUnsurveyedReq(boolean negate) {
            this.negate = negate;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            boolean result = planet.getMarket() != null && planet.getMarket().getSurveyLevel() == SurveyLevel.NONE;
            if (negate) result = !result;
            return result;
        }
    }
    public static class PlanetIsGasGiantReq implements PlanetRequirement {
        protected boolean negate = false;
        public PlanetIsGasGiantReq() {
            this(false);
        }
        public PlanetIsGasGiantReq(boolean negate) {
            this.negate = negate;
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            boolean result = planet.isGasGiant();
            if (negate) result = !result;
            return result;
        }
    }
    public static class SystemHasPulsarReq implements StarSystemRequirement {
        protected boolean negate = false;
        public SystemHasPulsarReq() {
            this(false);
        }
        public SystemHasPulsarReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = Misc.hasPulsar(system);
            if (negate) result = !result;
            return result;
        }
    }
    
    public static class SystemHasAtLeastJumpPointsReq implements StarSystemRequirement {
        protected int min = 0;
        public SystemHasAtLeastJumpPointsReq(int min) {
            this.min = min;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            return system.getJumpPoints().size() >= min;
        }
    }
    
    public static class SystemIsNebulaReq implements StarSystemRequirement {
        protected boolean negate = false;
        public SystemIsNebulaReq() {
            this(false);
        }
        public SystemIsNebulaReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = system.isNebula();
            if (negate) result = !result;
            return result;
        }
    }
    public static class SystemIsBlackHoleReq implements StarSystemRequirement {
        protected boolean negate = false;
        public SystemIsBlackHoleReq() {
            this(false);
        }
        public SystemIsBlackHoleReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = system.getStar() != null && system.getStar().getSpec().isBlackHole();
            if (negate) result = !result;
            return result;
        }
    }
    public static class StarSystemUnexploredReq implements StarSystemRequirement {
        protected boolean negate = false;
        public StarSystemUnexploredReq() {
            this(false);
        }
        public StarSystemUnexploredReq(boolean negate) {
            this.negate = negate;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
//          if (system.getNameWithNoType().equals("Stella Vitae")) {
//              System.out.println("wefwefwef");
//          }
            boolean result = !system.isEnteredByPlayer();
            if (DebugFlags.ALLOW_VIEW_UNEXPLORED_SYSTEM_MAP) {
                result = system.getDaysSinceLastPlayerVisit() >= 100000f;
            }
            if (negate) result = !result;
            return result;
        }
    }
    
    public static class StarSystemDaysSincePlayerVisitReq implements StarSystemRequirement {
        protected float days;
        public StarSystemDaysSincePlayerVisitReq(float days) {
            this.days = days;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            boolean result = system.getDaysSinceLastPlayerVisit() >= days;
            return result;
        }
    }
    public static class StarSystemHasNumPlanetsReq implements StarSystemRequirement {
        protected int num;
        public StarSystemHasNumPlanetsReq(int num) {
            this.num = num;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            int stars = 0;
            if (system.getStar() != null) stars++;
            if (system.getSecondary() != null) stars++;
            if (system.getTertiary() != null) stars++;
            return system.getPlanets().size() - stars >= num;
        }
    }
    
    public static class StarSystemHasNumTerrainReq implements StarSystemRequirement {
        protected int num;
        public StarSystemHasNumTerrainReq(int num) {
            this.num = num;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            return system.getTerrainCopy().size() >= num;
        }
    }
    
    public static class StarSystemHasNumPlanetsAndTerrainReq implements StarSystemRequirement {
        protected int num;
        public StarSystemHasNumPlanetsAndTerrainReq(int num) {
            this.num = num;
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            int stars = 0;
            if (system.getStar() != null) stars++;
            if (system.getSecondary() != null) stars++;
            if (system.getTertiary() != null) stars++;
            return system.getPlanets().size() - stars + system.getTerrainCopy().size() >= num;
        }
    }
    
    public static class StringCollectionReqs {
        public ReqMode mode;
        List<String> tags = new ArrayList<String>();
        public StringCollectionReqs(ReqMode mode, String ... tags) {
            this.mode = mode;
            for (String tag : tags) {
                this.tags.add(tag);
            }
        }
        public boolean matchesRequirements(Collection<String> set) {
            switch (mode) {
            case ALL:
                for (String tag : tags) if (!set.contains(tag)) return false;
                return true;
            case ANY:
                for (String tag : tags) if (set.contains(tag)) return true;
                return false;
            case NOT_ALL:
                for (String tag : tags) if (!set.contains(tag)) return true;
                return false;
            case NOT_ANY:
                for (String tag : tags) if (set.contains(tag)) return false;
                return true;
            }
            return false;
        }
    }
    
    public static class RequiredSystemTags extends StringCollectionReqs implements StarSystemRequirement {
        public RequiredSystemTags(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean systemMatchesRequirement(StarSystemAPI system) {
            return matchesRequirements(system.getTags());
        }
    }
    public static class RequiredTerrainTags extends StringCollectionReqs implements TerrainRequirement {
        public RequiredTerrainTags(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean terrainMatchesRequirement(CampaignTerrainAPI terrain) {
            return matchesRequirements(terrain.getTags());
        }
    }
    public static class RequiredPlanetTags extends StringCollectionReqs implements PlanetRequirement {
        public RequiredPlanetTags(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            return matchesRequirements(planet.getTags());
        }
    }
    public static class RequiredEntityTags extends StringCollectionReqs implements EntityRequirement {
        public RequiredEntityTags(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean entityMatchesRequirement(SectorEntityToken entity) {
            return matchesRequirements(entity.getTags());
        }
    }
    public static class RequiredPlanetConditions extends StringCollectionReqs implements PlanetRequirement {
        public RequiredPlanetConditions(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean planetMatchesRequirement(PlanetAPI planet) {
            List<String> set = new ArrayList<String>();
            if (planet.getMarket() != null) {
                for (MarketConditionAPI mc : planet.getMarket().getConditions()) {
                    set.add(mc.getId());
                }
            }
            return matchesRequirements(set);
        }
    }
    
    public static class RequiredCommodityTags extends StringCollectionReqs implements CommodityRequirement {
        public RequiredCommodityTags(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
            List<String> set = new ArrayList<String>();
            set.addAll(com.getCommodity().getTags());
            return matchesRequirements(set);
        }
    }
    
    public static class RequiredMarketConditions extends StringCollectionReqs implements MarketRequirement {
        public RequiredMarketConditions(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            List<String> set = new ArrayList<String>();
            for (MarketConditionAPI mc : market.getConditions()) {
                set.add(mc.getId());
            }
            return matchesRequirements(set);
        }
    }
    
    public static class RequiredMarketIndustries extends StringCollectionReqs implements MarketRequirement {
        public RequiredMarketIndustries(ReqMode mode, String[] tags) {
            super(mode, tags);
        }
        public boolean marketMatchesRequirement(MarketAPI market) {
            List<String> set = new ArrayList<String>();
            for (Industry ind : market.getIndustries()) {
                set.add(ind.getId());
            }
            return matchesRequirements(set);
        }
    }
    
    
    public static class SearchData {
        public List<GenericRequirement> systemReqs = new ArrayList<GenericRequirement>();
        public List<GenericRequirement> systemPrefs = new ArrayList<GenericRequirement>();
        public List<PlanetRequirement> planetReqs = new ArrayList<PlanetRequirement>();
        public List<PlanetRequirement> planetPrefs = new ArrayList<PlanetRequirement>();
        public List<EntityRequirement> entityReqs = new ArrayList<EntityRequirement>();
        public List<EntityRequirement> entityPrefs = new ArrayList<EntityRequirement>();
        public List<MarketRequirement> marketReqs = new ArrayList<MarketRequirement>();
        public List<MarketRequirement> marketPrefs = new ArrayList<MarketRequirement>();
        public List<TerrainRequirement> terrainReqs = new ArrayList<TerrainRequirement>();
        public List<TerrainRequirement> terrainPrefs = new ArrayList<TerrainRequirement>();
        public List<CommodityRequirement> commodityReqs = new ArrayList<CommodityRequirement>();
        public List<CommodityRequirement> commodityPrefs = new ArrayList<CommodityRequirement>();
        
        List<StarSystemAPI> matchingSystems = null;
        List<StarSystemAPI> preferredSystems = null;
        
        List<MarketAPI> matchingMarkets = null;
        List<MarketAPI> preferredMarkets = null;
    }
    
    protected transient SearchData search = new SearchData();
    
    public SearchData getSearch() {
        return search;
    }
    public void resetSearch() {
        search = new SearchData();
    }
    
    public void requireSystemInterestingAndNotCore() {
        requireSystemTags(ReqMode.NOT_ANY, Tags.THEME_CORE);
        preferSystemTags(ReqMode.ANY, Tags.THEME_INTERESTING, Tags.THEME_INTERESTING_MINOR);
    }
    public void requireSystemInterestingAndNotUnsafeOrCore() {
        requireSystemTags(ReqMode.NOT_ANY, Tags.THEME_UNSAFE, Tags.THEME_CORE);
        preferSystemTags(ReqMode.ANY, Tags.THEME_INTERESTING, Tags.THEME_INTERESTING_MINOR);
    }
    public void preferSystemInteresting() {
        preferSystemTags(ReqMode.ANY, Tags.THEME_INTERESTING, Tags.THEME_INTERESTING_MINOR);
    }
    
    public void preferSystemInDirectionOfOtherMissions() {
        search.systemPrefs.add(new SystemInDirectionOfOtherMissionsReq(this, 1f));
    }
    
    public void requireSystemInDirection(float dir, float arc) {
        search.systemReqs.add(new SystemInDirection(this, dir, arc));
    }
    
    public void preferSystemInDirection(float dir, float arc) {
        search.systemPrefs.add(new SystemInDirection(this, dir, arc));
    }
    
    public void requireSystemInDirectionFrom(Vector2f from, float dir, float arc) {
        search.systemReqs.add(new SystemInDirectionFrom(from, dir, arc));
    }
    
    public void preferSystemInDirectionFrom(Vector2f from, float dir, float arc) {
        search.systemPrefs.add(new SystemInDirectionFrom(from, dir, arc));
    }
    
    public void preferPlanetInDirectionOfOtherMissions() {
        search.planetPrefs.add(new PlanetInDirectionOfOtherMissionsReq(this, 1f));
    }
    
    public void preferEntityInDirectionOfOtherMissions() {
        search.entityPrefs.add(new EntityInDirectionOfOtherMissionsReq(this, 1f));
    }
    
    public void preferTerrainInDirectionOfOtherMissions() {
        search.terrainPrefs.add(new TerrainInDirectionOfOtherMissionsReq(this, 1f));
    }
    
    public void preferMarketInDirectionOfOtherMissions() {
        search.marketPrefs.add(new MarketInDirectionOfOtherMissionsReq(this, 1f));
    }
    
    public void requireSystemTags(ReqMode mode, String ... tags) {
        search.systemReqs.add(new RequiredSystemTags(mode, tags));
    }
    public void preferSystemTags(ReqMode mode, String ... tags) {
        search.systemPrefs.add(new RequiredSystemTags(mode, tags));
    }
    public void requireSystemHasBase(String factionId) {
        search.systemReqs.add(new SystemHasBaseReq(factionId));
    }
    public void preferSystemHasBase(String factionId) {
        search.systemPrefs.add(new SystemHasBaseReq(factionId));
    }
    public void requireSystemHasColony(String factionId, int minSize) {
        search.systemReqs.add(new SystemHasColonyReq(factionId, minSize));
    }
    public void preferSystemHasColony(String factionId, int minSize) {
        search.systemPrefs.add(new SystemHasColonyReq(factionId, minSize));
    }
    
    public void requireSystemHasAtLeastNumJumpPoints(int min) {
        search.systemReqs.add(new SystemHasAtLeastJumpPointsReq(min));
    }
    public void preferSystemHasAtLeastNumJumpPoints(int min) {
        search.systemPrefs.add(new SystemHasAtLeastJumpPointsReq(min));
    }
    
    public void requireSystemUnexplored() {
        search.systemReqs.add(new StarSystemUnexploredReq());
    }
    public void preferSystemUnexplored() {
        search.systemPrefs.add(new StarSystemUnexploredReq());
        preferSystemNotEnteredByPlayerFor(365f); // fallback for when everything is explored
    }
    
    public void requireSystemNotEnteredByPlayerFor(float days) {
        search.systemReqs.add(new StarSystemDaysSincePlayerVisitReq(days));
    }
    public void preferSystemNotEnteredByPlayerFor(float days) {
        search.systemPrefs.add(new StarSystemDaysSincePlayerVisitReq(days));
    }
    
    public void requireSystemExplored() {
        search.systemReqs.add(new StarSystemUnexploredReq(true));
    }
    public void preferSystemExplored() {
        search.systemPrefs.add(new StarSystemUnexploredReq(true));
    }
    public void requireSystemHasNumPlanets(int num) {
        search.systemReqs.add(new StarSystemHasNumPlanetsReq(num));
    }
    public void preferSystemHasNumPlanets(int num) {
        search.systemPrefs.add(new StarSystemHasNumPlanetsReq(num));
    }
    
    public void requireSystemHasNumTerrain(int num) {
        search.systemReqs.add(new StarSystemHasNumTerrainReq(num));
    }
    public void preferSystemHasNumTerrain(int num) {
        search.systemPrefs.add(new StarSystemHasNumTerrainReq(num));
    }
    
    public void requireSystemHasNumPlanetsAndTerrain(int num) {
        search.systemReqs.add(new StarSystemHasNumPlanetsAndTerrainReq(num));
    }
    public void preferSystemHasNumPlanetsAndTerrain(int num) {
        search.systemPrefs.add(new StarSystemHasNumTerrainReq(num));
    }
    
    public void requireSystemIsDense() {
        requireSystemHasNumPlanets(3);
        requireSystemHasNumTerrain(3);
        requireSystemHasNumPlanetsAndTerrain(10);
    }
    public void preferSystemIsDense() {
        preferSystemHasNumPlanets(3);
        preferSystemHasNumTerrain(3);
        preferSystemHasNumPlanetsAndTerrain(10);
    }
    
    public void requireSystemBlackHole() {
        search.systemReqs.add(new SystemIsBlackHoleReq());
    }
    public void requireSystemNebula() {
        search.systemReqs.add(new SystemIsNebulaReq());
    }
    public void requireSystemHasPulsar() {
        search.systemReqs.add(new SystemHasPulsarReq());
    }
    public void preferSystemBlackHole() {
        search.systemPrefs.add(new SystemIsBlackHoleReq());
    }
    public void preferSystemNebula() {
        search.systemPrefs.add(new SystemIsNebulaReq());
    }
    public void preferSystemHasPulsar() {
        search.systemPrefs.add(new SystemHasPulsarReq());
    }
    
    public void requireSystemBlackHoleOrPulsarOrNebula() {
        search.systemReqs.add(new MultipleStarSystemRequirements(ReqMode.ANY, 
                new SystemIsBlackHoleReq(), new SystemHasPulsarReq(), new SystemIsNebulaReq()));
    }
    public void preferSystemBlackHoleOrPulsarOrNebula() {
        search.systemPrefs.add(new MultipleStarSystemRequirements(ReqMode.ANY, 
                new SystemIsBlackHoleReq(), new SystemHasPulsarReq(), new SystemIsNebulaReq()));
    }
    
    public void requireSystemBlackHoleOrNebula() {
        search.systemReqs.add(new MultipleStarSystemRequirements(ReqMode.ANY, 
                new SystemIsBlackHoleReq(), new SystemIsNebulaReq()));
    }
    public void preferSystemBlackHoleOrNebula() {
        search.systemPrefs.add(new MultipleStarSystemRequirements(ReqMode.ANY, 
                new SystemIsBlackHoleReq(), new SystemIsNebulaReq()));
    }
    
    public void requireSystemNotBlackHole() {
        search.systemReqs.add(new SystemIsBlackHoleReq(true));
    }
    public void requireSystemNotNebula() {
        search.systemReqs.add(new SystemIsNebulaReq(true));
    }
    public void requireSystemNotHasPulsar() {
        search.systemReqs.add(new SystemHasPulsarReq(true));
    }
    public void requireSystemNotAlreadyUsedForStory() {
        requireSystemTags(ReqMode.NOT_ANY, Tags.SYSTEM_ALREADY_USED_FOR_STORY);
    }
    
    public void setSystemWasUsedForStory(Object stage, StarSystemAPI system) {
        beginStageTrigger(stage);
        triggerAddTagAfterDelay(0f, system, Tags.SYSTEM_ALREADY_USED_FOR_STORY);
        endTrigger();
    }
    public void preferSystemNotBlackHole() {
        search.systemPrefs.add(new SystemIsBlackHoleReq(true));
    }
    public void preferSystemNotNebula() {
        search.systemPrefs.add(new SystemIsNebulaReq(true));
    }
    public void preferSystemNotPulsar() {
        search.systemPrefs.add(new SystemHasPulsarReq(true));
    }
    
    public void requireSystemHasSafeStars() {
        requireSystemNotBlackHole();
        requireSystemNotHasPulsar();
    }
    
    public static float INNER_SECTOR_PORTION_OF_HEIGHT = 0.7f;
    public static float NON_FRINGE_PORTION_OF_HEIGHT = 0.7f;
    public void requireSystemInInnerSector() {
        search.systemReqs.add(new SystemInInnerSectorReq());
    }
    public void preferSystemInInnerSector() {
        search.systemPrefs.add(new SystemInInnerSectorReq());
    }
    public void requireSystemOnFringeOfSector() {
        search.systemReqs.add(new SystemOnFringeOfSectorReq());
    }
    public void preferSystemOnFringeOfSector() {
        search.systemPrefs.add(new SystemOnFringeOfSectorReq());
    }
    
    public void requireSystemWithinRangeOf(Vector2f location, float rangeLY) {
        search.systemReqs.add(new SystemWithinRangeReq(location, 0, rangeLY));
    }
    public void preferSystemWithinRangeOf(Vector2f location, float rangeLY) {
        search.systemPrefs.add(new SystemWithinRangeReq(location, 0, rangeLY));
    }
    
    public void requireSystemOutsideRangeOf(Vector2f location, float rangeLY) {
        search.systemReqs.add(new SystemWithinRangeReq(location, rangeLY, 1000000f));
    }
    public void preferSystemOutsideRangeOf(Vector2f location, float rangeLY) {
        search.systemPrefs.add(new SystemWithinRangeReq(location, rangeLY, 1000000));
    }
    
    public void requireSystemWithinRangeOf(Vector2f location, float minRangeLY, float maxRangeLY) {
        search.systemReqs.add(new SystemWithinRangeReq(location, minRangeLY, maxRangeLY));
    }
    public void preferSystemWithinRangeOf(Vector2f location, float minRangeLY, float maxRangeLY) {
        search.systemPrefs.add(new SystemWithinRangeReq(location, minRangeLY, maxRangeLY));
    }
    
    public void requirePlanetNotStar() {
        requirePlanetTags(ReqMode.NOT_ANY, Tags.STAR);
    }
    public void requirePlanetIsStar() {
        requirePlanetTags(ReqMode.ALL, Tags.STAR);
    }
    
    public void requirePlanetNotGasGiant() {
        search.planetReqs.add(new PlanetIsGasGiantReq(true));
    }
    public void preferPlanetNonGasGiant() {
        search.planetPrefs.add(new PlanetIsGasGiantReq(true));
    }
    
    public void requirePlanetNotNearJumpPoint(float minDist) {
        search.planetReqs.add(new PlanetOrbitIsNotNearJumpPoint(minDist));
    }
    public void preferPlanetNotNearJumpPoint(float minDist) {
        search.planetPrefs.add(new PlanetOrbitIsNotNearJumpPoint(minDist));
    }
    
    public void requirePlanetIsGasGiant() {
        search.planetReqs.add(new PlanetIsGasGiantReq());
    }
    public void preferPlanetIsGasGiant() {
        search.planetPrefs.add(new PlanetIsGasGiantReq());
    }
    
    public void requirePlanetPopulated() {
        search.planetReqs.add(new PlanetIsPopulatedReq());
    }
    public void preferPlanetPopulated() {
        search.planetPrefs.add(new PlanetIsPopulatedReq());
    }
    public void requirePlanetUnpopulated() {
        search.planetReqs.add(new PlanetIsPopulatedReq(true));
    }
    public void preferPlanetUnpopulated() {
        search.planetPrefs.add(new PlanetIsPopulatedReq(true));
    }
    
    public void requirePlanetTags(ReqMode mode, String ... tags) {
        search.planetReqs.add(new RequiredPlanetTags(mode, tags));
    }
    public void preferPlanetTags(ReqMode mode, String ... tags) {
        search.planetPrefs.add(new RequiredPlanetTags(mode, tags));
    }
    
    public void requirePlanetConditions(ReqMode mode, String ... tags) {
        search.planetReqs.add(new RequiredPlanetConditions(mode, tags));
    }
    public void preferPlanetConditions(ReqMode mode, String ... conditions) {
        search.planetPrefs.add(new RequiredPlanetConditions(mode, conditions));
    }
    
    public void requirePlanetNotFullySurveyed() {
        search.planetReqs.add(new PlanetFullySurveyedReq(true));
    }
    public void preferPlanetNotFullySurveyed() {
        search.planetPrefs.add(new PlanetFullySurveyedReq(true));
    }
    public void requirePlanetFullySurveyed() {
        search.planetReqs.add(new PlanetFullySurveyedReq());
    }
    public void preferPlanetFullySurveyed() {
        search.planetPrefs.add(new PlanetFullySurveyedReq());
    }
    public void preferPlanetUnsurveyed() {
        search.planetPrefs.add(new PlanetUnsurveyedReq());
    }
    public void requirePlanetUnsurveyed() {
        search.planetReqs.add(new PlanetUnsurveyedReq());
    }
    
    public void requirePlanetWithRuins() {
        requirePlanetConditions(ReqMode.ANY, Conditions.RUINS_SCATTERED, Conditions.RUINS_WIDESPREAD,
                                Conditions.RUINS_EXTENSIVE, Conditions.RUINS_VAST);
    }
    public void preferPlanetWithRuins() {
        preferPlanetConditions(ReqMode.ANY, Conditions.RUINS_SCATTERED, Conditions.RUINS_WIDESPREAD,
                Conditions.RUINS_EXTENSIVE, Conditions.RUINS_VAST);
    }
    public void requirePlanetWithoutRuins() {
        requirePlanetConditions(ReqMode.NOT_ANY, Conditions.RUINS_SCATTERED, Conditions.RUINS_WIDESPREAD,
                Conditions.RUINS_EXTENSIVE, Conditions.RUINS_VAST);
    }
    public void preferPlanetWithoutRuins() {
        preferPlanetConditions(ReqMode.NOT_ANY, Conditions.RUINS_SCATTERED, Conditions.RUINS_WIDESPREAD,
                Conditions.RUINS_EXTENSIVE, Conditions.RUINS_VAST);
    }
    
    public void requirePlanetUnexploredRuins() {
        search.planetReqs.add(new PlanetUnexploredRuinsReq());
    }
    public void preferPlanetUnexploredRuins() {
        search.planetPrefs.add(new PlanetUnexploredRuinsReq());
    }
    
    
    public void requireEntityTags(ReqMode mode, String ... tags) {
        search.entityReqs.add(new RequiredEntityTags(mode, tags));
    }
    public void preferEntityTags(ReqMode mode, String ... tags) {
        search.entityPrefs.add(new RequiredEntityTags(mode, tags));
    }
    
    public void requireEntityType(String ... types) {
        search.entityReqs.add(new EntityTypeReq(types));
    }
    public void preferEntityType(String ... types) {
        search.entityPrefs.add(new EntityTypeReq(types));
    }
    
    public void requireEntityMemoryFlags(String ... flags) {
        search.entityReqs.add(new EntityMemoryReq(flags));
    }
    public void preferEntityMemoryFlags(String ... flags) {
        search.entityPrefs.add(new EntityMemoryReq(flags));
    }
    
    public void requireEntityUndiscovered() {
        search.entityReqs.add(new EntityUndiscoveredReq(false));
    }
    public void preferEntityUndiscovered() {
        search.entityPrefs.add(new EntityUndiscoveredReq(false));
    }
    
    public void requireEntityNot(final SectorEntityToken entity) {
        search.entityReqs.add(new EntityRequirement() {
            public boolean entityMatchesRequirement(SectorEntityToken param) {
                return entity != param;
            }
        });
    }
    public void requirePlanetNot(final PlanetAPI planet) {
        search.planetReqs.add(new PlanetRequirement() {
            public boolean planetMatchesRequirement(PlanetAPI param) {
                return planet != param;
            }
        });
    }
    public void requireSystemNot(final StarSystemAPI system) {
        if (system == null) return;
        search.systemReqs.add(new StarSystemRequirement() {
            public boolean systemMatchesRequirement(StarSystemAPI param) {
                return system != param;
            }
        });
    }
    
    public void requireSystemIs(final StarSystemAPI system) {
        search.systemReqs.add(new StarSystemRequirement() {
            public boolean systemMatchesRequirement(StarSystemAPI param) {
                return system == param;
            }
        });
    }
    
    public void requireSystem(StarSystemRequirement req) {
        search.systemReqs.add(req);
    }
    public void preferSystem(StarSystemRequirement req) {
        search.systemPrefs.add(req);
    }
    
    
    @SuppressWarnings("unchecked")
    protected void findMatching(List reqs, List prefs, List params,
                                List matches, List preferred) {
        if (reqs.isEmpty() && prefs.isEmpty()) {
            matches.addAll(params);
            return;
        }
        
        OUTER: for (Object param : params) {
            for (Object req : reqs) {
                if (!matchesReq((GenericRequirement) req, param)) continue OUTER;
            }
            matches.add(param);
        }
    
        // preferred: check prefs requirements in order, skip any that would produce
        // an empty result so e.g. if A, B, and C are required, then:
        // 1) Retain everything that meets A, say this is not an empty set
        // 2) If A && B is an empty set, skip B
        // 3) Then retain everything that meets C - so, A && C is the final set
        // Note that if the order is [B, A, C], the result would be different - B && C,
        // or just C (if nothing met B)
        List matchingPrefs = new ArrayList(matches);
        boolean foundAny = false;
        for (Object req : prefs) {
            List retain = new ArrayList();
            for (Object curr : matchingPrefs) {
                if (matchesReq((GenericRequirement) req, curr)) {
                    retain.add(curr);
                }
            }
            if (retain.isEmpty()) continue;
            foundAny = true;
            matchingPrefs.retainAll(retain);
        }
        if (foundAny) {
            preferred.addAll(matchingPrefs);
        }
    
//      OUTER: for (Object param : params) {
//          for (Object req : prefs) {
//              if (!matchesReq((GenericRequirement) req, param)) continue OUTER;
//          }
//          preferred.add(param);
//      }
    }
    @SuppressWarnings("unchecked")
    public Object pickFromMatching(List matches, List preferred) {
        WeightedRandomPicker pref = new WeightedRandomPicker(genRandom);
        WeightedRandomPicker other = new WeightedRandomPicker(genRandom);
        pref.addAll(preferred);
        other.addAll(matches);
        
        if (!pref.isEmpty()) {
            return pref.pick();
        }
        
        return other.pick();
    }
    
    protected void findMatchingSystems() {
        requireSystemTags(ReqMode.NOT_ANY, Tags.THEME_HIDDEN);
        search.matchingSystems = new ArrayList<StarSystemAPI>();
        search.preferredSystems = new ArrayList<StarSystemAPI>();
        findMatching(search.systemReqs, search.systemPrefs, Global.getSector().getStarSystems(),
                     search.matchingSystems, search.preferredSystems);
    }
    
    public StarSystemAPI pickSystem() {
        return pickSystem(true);
    }
    public StarSystemAPI pickSystem(boolean resetSearch) {
        findMatchingSystems();
        StarSystemAPI system = (StarSystemAPI) pickFromMatching(search.matchingSystems, search.preferredSystems);
        if (resetSearch) resetSearch();
        return system;
    }
    
    protected transient boolean makeSystemPreferencesMoreImportant = false;
    public void searchMakeSystemPreferencesMoreImportant(boolean value) {
        makeSystemPreferencesMoreImportant = value;
    }
    
    public PlanetAPI pickPlanet() {
        return pickPlanet(true);
    }
    public PlanetAPI pickPlanet(boolean resetSearch) {
        findMatchingSystems();
        
        List<PlanetAPI> inPreferredSystems = new ArrayList<PlanetAPI>();
        List<PlanetAPI> inMatchingSystems = new ArrayList<PlanetAPI>();
        for (StarSystemAPI system : search.matchingSystems) {
            for (PlanetAPI planet : system.getPlanets()) {
                if (planet.hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) continue;
                inMatchingSystems.add(planet);
            }
            //inMatchingSystems.addAll(system.getPlanets());
        }
        for (StarSystemAPI system : search.preferredSystems) {
            for (PlanetAPI planet : system.getPlanets()) {
                if (planet.hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) continue;
                inPreferredSystems.add(planet);
            }
            //inPreferredSystems.addAll(system.getPlanets());
        }
            
        List<PlanetAPI> matchesInPref = new ArrayList<PlanetAPI>();
        List<PlanetAPI> preferredInPref = new ArrayList<PlanetAPI>();
        findMatching(search.planetReqs, search.planetPrefs, inPreferredSystems, matchesInPref, preferredInPref);
        if (!preferredInPref.isEmpty()) {
            if (resetSearch) resetSearch();
            return (PlanetAPI) pickOneObject(preferredInPref);
        }
        List<PlanetAPI> matchesInMatches = new ArrayList<PlanetAPI>();
        List<PlanetAPI> preferredInMatches = new ArrayList<PlanetAPI>();
        findMatching(search.planetReqs, search.planetPrefs, inMatchingSystems, matchesInMatches, preferredInMatches);
        if (makeSystemPreferencesMoreImportant) {
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (PlanetAPI) pickOneObject(matchesInPref);
            }
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (PlanetAPI) pickOneObject(preferredInMatches);
            }
        } else {
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (PlanetAPI) pickOneObject(preferredInMatches);
            }
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (PlanetAPI) pickOneObject(matchesInPref);
            }
        }
        
        if (resetSearch) resetSearch();
        return (PlanetAPI) pickOneObject(matchesInMatches);
        
//      WeightedRandomPicker<StarSystemAPI> pref = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      WeightedRandomPicker<StarSystemAPI> other = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      pref.addAll(search.preferredSystems);
//      other.addAll(search.matchingSystems);
//      
//      WeightedRandomPicker<PlanetAPI> allMatches = new WeightedRandomPicker<PlanetAPI>(genRandom);
//      while (!pref.isEmpty() || !other.isEmpty()) {
//          StarSystemAPI pick = pref.pickAndRemove();
//          if (pick == null) pick = other.pickAndRemove();
//          if (pick == null) break;
//          
//          WeightedRandomPicker<PlanetAPI> matches = new WeightedRandomPicker<PlanetAPI>(genRandom);
//          
//          List<PlanetAPI> planets = new ArrayList<PlanetAPI>(pick.getPlanets());
//          WeightedRandomPicker<PlanetAPI> preferred = new WeightedRandomPicker<PlanetAPI>(genRandom);
//          OUTER: for (PlanetAPI planet : planets) {
//              for (PlanetRequirement req : search.planetReqs) {
//                  if (!req.planetMatchesRequirement(planet)) continue OUTER;
//              }
//              allMatches.add(planet);
//              matches.add(planet);
//          }
//          
//          
//          List<PlanetAPI> matchingPrefs = new ArrayList<PlanetAPI>(matches.getItems());
//          boolean foundAny = false;
//          for (PlanetRequirement req : search.planetPrefs) {
//              List<PlanetAPI> retain = new ArrayList<PlanetAPI>();
//              for (PlanetAPI curr : matchingPrefs) {
//                  if (req.planetMatchesRequirement(curr)) {
//                      retain.add(curr);
//                  }
//              }
//              if (retain.isEmpty()) continue;
//              foundAny = true;
//              matchingPrefs.retainAll(retain);
//          }
//          if (foundAny) {
//              preferred.addAll(matchingPrefs);
//          }
//          
//          
//          if (!preferred.isEmpty()) {
//              if (resetSearch) resetSearch();
//              return preferred.pick();
//          }
//      }
//      
//      if (resetSearch) resetSearch();
//      return allMatches.pick();
    }
    
    public SectorEntityToken pickEntity() {
        return pickEntity(true);
    }
    public SectorEntityToken pickEntity(boolean resetSearch) {
        findMatchingSystems();
        
        List<SectorEntityToken> inPreferredSystems = new ArrayList<SectorEntityToken>();
        List<SectorEntityToken> inMatchingSystems = new ArrayList<SectorEntityToken>();
        for (StarSystemAPI system : search.matchingSystems) {
            List<SectorEntityToken> entities = new ArrayList<SectorEntityToken>(system.getAllEntities());
            for (SectorEntityToken entity : entities) {
                if (entity instanceof AsteroidAPI) continue;
                if (entity.hasTag(Tags.EXPIRES)) continue;
                if (entity.hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) continue;
                //if (!(entity.getCustomPlugin() instanceof DerelictShipEntityPlugin)) continue;
                inMatchingSystems.add(entity);
            }
        }
        for (StarSystemAPI system : search.preferredSystems) {
            List<SectorEntityToken> entities = new ArrayList<SectorEntityToken>(system.getAllEntities());
            for (SectorEntityToken entity : entities) {
                if (entity instanceof AsteroidAPI) continue;
                if (entity.hasTag(Tags.EXPIRES)) continue;
                if (entity.hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) continue;
                inPreferredSystems.add(entity);
            }
        }
            
        List<SectorEntityToken> matchesInPref = new ArrayList<SectorEntityToken>();
        List<SectorEntityToken> preferredInPref = new ArrayList<SectorEntityToken>();
        findMatching(search.entityReqs, search.entityPrefs, inPreferredSystems, matchesInPref, preferredInPref);
        if (!preferredInPref.isEmpty()) {
            if (resetSearch) resetSearch();
            return (SectorEntityToken) pickOneObject(preferredInPref);
        }
        List<SectorEntityToken> matchesInMatches = new ArrayList<SectorEntityToken>();
        List<SectorEntityToken> preferredInMatches = new ArrayList<SectorEntityToken>();
        findMatching(search.entityReqs, search.entityPrefs, inMatchingSystems, matchesInMatches, preferredInMatches);
        if (makeSystemPreferencesMoreImportant) {
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (SectorEntityToken) pickOneObject(matchesInPref);
            }
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (SectorEntityToken) pickOneObject(preferredInMatches);
            }
        } else {
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (SectorEntityToken) pickOneObject(preferredInMatches);
            }
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (SectorEntityToken) pickOneObject(matchesInPref);
            }
        }
        
        if (resetSearch) resetSearch();
        return (SectorEntityToken) pickOneObject(matchesInMatches);
        
        
//      WeightedRandomPicker<StarSystemAPI> pref = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      WeightedRandomPicker<StarSystemAPI> other = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      pref.addAll(search.preferredSystems);
//      other.addAll(search.matchingSystems);
//      
//      WeightedRandomPicker<SectorEntityToken> allMatches = new WeightedRandomPicker<SectorEntityToken>(genRandom);
//      while (!pref.isEmpty() || !other.isEmpty()) {
//          StarSystemAPI pick = pref.pickAndRemove();
//          if (pick == null) pick = other.pickAndRemove();
//          if (pick == null) break;
//          
//          WeightedRandomPicker<SectorEntityToken> matches = new WeightedRandomPicker<SectorEntityToken>(genRandom);
//          
//          List<SectorEntityToken> entities = new ArrayList<SectorEntityToken>(pick.getAllEntities());
//          WeightedRandomPicker<SectorEntityToken> preferred = new WeightedRandomPicker<SectorEntityToken>(genRandom);
//          OUTER: for (SectorEntityToken entity : entities) {
//              if (entity instanceof AsteroidAPI) continue;
//              if (entity.hasTag(Tags.EXPIRES)) continue;
//              for (EntityRequirement req : search.entityReqs) {
//                  if (!req.entityMatchesRequirement(entity)) continue OUTER;
//              }
//              allMatches.add(entity);
//              matches.add(entity);
//          }
//          
//          
//          List<SectorEntityToken> matchingPrefs = new ArrayList<SectorEntityToken>(matches.getItems());
//          boolean foundAny = false;
//          for (EntityRequirement req : search.entityPrefs) {
//              List<SectorEntityToken> retain = new ArrayList<SectorEntityToken>();
//              for (SectorEntityToken curr : matchingPrefs) {
//                  if (req.entityMatchesRequirement(curr)) {
//                      retain.add(curr);
//                  }
//              }
//              if (retain.isEmpty()) continue;
//              foundAny = true;
//              matchingPrefs.retainAll(retain);
//          }
//          if (foundAny) {
//              preferred.addAll(matchingPrefs);
//          }
//          
//          
//          if (!preferred.isEmpty()) {
//              if (resetSearch) resetSearch();
//              return preferred.pick();
//          }
//      }
//      
//      if (resetSearch) resetSearch();
//      return allMatches.pick();
    }
    
 
    
    protected void findMatchingMarkets() {
        List<MarketAPI> markets = new ArrayList<MarketAPI>();;
        for (MarketAPI market : Global.getSector().getEconomy().getMarketsCopy()) {
            if (market.hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) {
                continue;
            }
            if (market.getPlanetEntity() != null && market.getPlanetEntity().hasTag(Tags.NOT_RANDOM_MISSION_TARGET)) {
                continue;
            }
            markets.add(market);
        }
//      System.out.println("BEGIN");
//      for (MarketAPI curr : markets) {
//          System.out.println(curr.getName());
//      }
//      System.out.println("END");
//      findMatchingSystems();
//      if (!(search.systemPrefs.isEmpty() && search.systemReqs.isEmpty())) {
//          Set<StarSystemAPI> systems = new HashSet<StarSystemAPI>(search.matchingSystems);
//          Iterator<MarketAPI> iter = markets.iterator();
//          while (iter.hasNext()) {
//              MarketAPI curr = iter.next();
//              if (!systems.contains(curr.getStarSystem())) {
//                  iter.remove();
//              }
//          }
//      }
        
        search.matchingMarkets = new ArrayList<MarketAPI>();
        search.preferredMarkets = new ArrayList<MarketAPI>();
        findMatching(search.marketReqs, search.marketPrefs, markets,
                            search.matchingMarkets, search.preferredMarkets);
    }
    
    public MarketAPI pickMarket() {
        return pickMarket(true);
    }
    public MarketAPI pickMarket(boolean resetSearch) {
        findMatchingMarkets();
        MarketAPI market = (MarketAPI) pickFromMatching(search.matchingMarkets, search.preferredMarkets);
        if (resetSearch) resetSearch();
        
        //if (true) return Global.getSector().getEconomy().getMarket("nomios");
        
        return market;
    }
    
    public CommodityOnMarketAPI pickCommodity() {
        return pickCommodity(true);
    }
    
    public CommodityOnMarketAPI pickCommodity(boolean resetSearch) {
        findMatchingMarkets();
        
        WeightedRandomPicker<CommodityOnMarketAPI> pref = new WeightedRandomPicker<CommodityOnMarketAPI>(genRandom);
        WeightedRandomPicker<CommodityOnMarketAPI> other = new WeightedRandomPicker<CommodityOnMarketAPI>(genRandom);
        
        for (MarketAPI market : search.matchingMarkets) {
            SKIP: for (CommodityOnMarketAPI com : market.getAllCommodities()) {
                if (com.isMeta()) continue;
                if (com.isNonEcon()) continue;
                
                for (CommodityRequirement req : search.commodityReqs) {
                    if (!req.commodityMatchesRequirement(com)) continue SKIP;
                }
                other.add(com);
            }
        }
        
        List<CommodityOnMarketAPI> matchingPrefs = new ArrayList<CommodityOnMarketAPI>(other.getItems());
        boolean foundAny = false;
        for (CommodityRequirement req : search.commodityPrefs) {
            List<CommodityOnMarketAPI> retain = new ArrayList<CommodityOnMarketAPI>();
            for (CommodityOnMarketAPI com : matchingPrefs) {
                if (req.commodityMatchesRequirement(com)) {
                    retain.add(com);
                }
            }
            if (retain.isEmpty()) continue;
            foundAny = true;
            matchingPrefs.retainAll(retain);
        }
        if (foundAny) {
            pref.addAll(matchingPrefs);
        }
 
        
        CommodityOnMarketAPI result = pref.pick();
        if (result == null) result = other.pick();
        if (resetSearch) resetSearch();
        
        return result;
    }
 
    
//  public void requireMarketFactionCustom(String flag) {
//      search.marketReqs.add(new MarketFactionCustomFlagReq(false, flag));
//  }
//  public void preferMarketFactionCustom(String flag) {
//      search.marketPrefs.add(new MarketFactionCustomFlagReq(false, flag));
//  }
//  public void requireMarketFactionNotCustom(String flag) {
//      search.marketReqs.add(new MarketFactionCustomFlagReq(true, flag));
//  }
//  public void preferMarketFactionNotCustom(String flag) {
//      search.marketPrefs.add(new MarketFactionCustomFlagReq(true, flag));
//  }
    
    public void requireMarketTacticallyBombardable() {
        search.marketReqs.add(new MarketTacticalBombardableReq(false));
    }
    public void requireMarketNotTacticallyBombardable() {
        search.marketReqs.add(new MarketTacticalBombardableReq(true));
    }
    public void preferMarketTacticallyBombardable() {
        search.marketPrefs.add(new MarketTacticalBombardableReq(false));
    }
    public void preferMarketNotTacticallyBombardable() {
        search.marketPrefs.add(new MarketTacticalBombardableReq(true));
    }
    public void requireMarketMilitary() {
        search.marketReqs.add(new MarketMilitaryReq());
    }
    public void preferMarketMilitary() {
        search.marketPrefs.add(new MarketMilitaryReq());
    }
    public void requireMarketNotMilitary() {
        search.marketReqs.add(new MarketNotMilitaryReq());
    }
    public void preferMarketNotMilitary() {
        search.marketPrefs.add(new MarketNotMilitaryReq());
    }
    
    public void requireMarketMemoryFlag(String key, Object value) {
        search.marketReqs.add(new MarketMemoryFlagReq(key, value));
    }
    public void preferMarketMemoryFlag(String key, Object value) {
        search.marketPrefs.add(new MarketMemoryFlagReq(key, value));
    }
    
    public void requireMarketHidden() {
        search.marketReqs.add(new MarketHiddenReq());
    }
    public void preferMarketHidden() {
        search.marketPrefs.add(new MarketHiddenReq());
    }
    public void requireMarketNotHidden() {
        search.marketReqs.add(new MarketNotHiddenReq());
    }
    public void preferMarketNotHidden() {
        search.marketPrefs.add(new MarketNotHiddenReq());
    }
    public void requireMarketNotInHyperspace() {
        search.marketReqs.add(new MarketNotInHyperReq());
    }
    public void preferMarketNotInHyperspace() {
        search.marketPrefs.add(new MarketNotInHyperReq());
    }
    
    
    public void requireMarketIs(String id) {
        search.marketReqs.add(new MarketIsReq(Global.getSector().getEconomy().getMarket(id), false));
    }
    public void requireMarketIs(final MarketAPI param) {
        search.marketReqs.add(new MarketIsReq(param, false));
    }
    public void preferMarketIs(final MarketAPI param) {
        search.marketPrefs.add(new MarketIsReq(param, false));
    }
    public void requireMarketIsNot(final MarketAPI param) {
        search.marketReqs.add(new MarketIsReq(param, true));
    }
    public void preferMarketIsNot(final MarketAPI param) {
        search.marketPrefs.add(new MarketIsReq(param, true));
    }
    
    public void requireMarketFaction(String ... factions) {
        search.marketReqs.add(new MarketFactionReq(false, factions));
    }
    public void preferMarketFaction(String ... factions) {
        search.marketPrefs.add(new MarketFactionReq(false, factions));
    }
    public void requireMarketFactionNot(String ... factions) {
        search.marketReqs.add(new MarketFactionReq(true, factions));
    }
    public void preferMarketFactionNot(String ... factions) {
        search.marketPrefs.add(new MarketFactionReq(true, factions));
    }
    
    public void requireMarketFactionNotPlayer() {
        requireMarketFactionNot(Factions.PLAYER);
    }
    
    public void requireMarketFactionHostileTo(String faction) {
        search.marketReqs.add(new MarketFactionHostileReq(false, faction));
    }
    public void preferMarketFactionHostileTo(String faction) {
        search.marketPrefs.add(new MarketFactionHostileReq(false, faction));
    }
    public void requireMarketFactionNotHostileTo(String faction) {
        search.marketReqs.add(new MarketFactionHostileReq(true, faction));
    }
    public void preferMarketFactionNotHostileTo(String faction) {
        search.marketPrefs.add(new MarketFactionHostileReq(true, faction));
    }
    
    protected LocationAPI[] convertLocations(String ... locations) {
        List<LocationAPI> result = new ArrayList<LocationAPI>();
        for (String s : locations) {
            if ("hyperspace".equals(s)) {
                result.add(Global.getSector().getHyperspace());
            } else {
                StarSystemAPI system = Global.getSector().getStarSystem(s);
//              if (Global.getSettings().isDevMode() && system == null) {
//                  throw new RuntimeException("Star system named [" + s + "] not found");
//              }
                if (system != null) {
                    result.add(system);
                }
            }
        }
        return result.toArray(new LocationAPI[0]);
    }
    public void requireMarketLocation(String ...locations) {
        requireMarketLocation(convertLocations(locations));
    }
    public void preferMarketLocation(String ... locations) {
        preferMarketLocation(convertLocations(locations));
    }
    public void requireMarketLocationNot(String ... locations) {
        requireMarketLocationNot(convertLocations(locations));
    }
    public void preferMarketLocationNot(String ... locations) {
        preferMarketLocationNot(convertLocations(locations));
    }
    public void requireMarketLocation(LocationAPI ... locations) {
        search.marketReqs.add(new MarketLocationReq(false, locations));
    }
    public void preferMarketLocation(LocationAPI ... locations) {
        search.marketPrefs.add(new MarketLocationReq(false, locations));
    }
    public void requireMarketLocationNot(LocationAPI ... locations) {
        search.marketReqs.add(new MarketLocationReq(true, locations));
    }
    public void preferMarketLocationNot(LocationAPI ... locations) {
        search.marketPrefs.add(new MarketLocationReq(true, locations));
    }
    
    public void requireMarketFactionCustom(ReqMode mode, String ... custom) {
        search.marketReqs.add(new MarketFactionCustomReq(mode, custom));
    }
    public void preferMarketFactionCustom(ReqMode mode, String ... custom) {
        search.marketPrefs.add(new MarketFactionCustomReq(mode, custom));
    }
    
    public void requireMarketSizeAtLeast(final int size) {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getSize() >= size;
            }
        });
    }
    public void preferMarketSizeAtLeast(final int size) {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getSize() >= size;
            }
        });
    }
    
    public void requireMarketSizeAtMost(final int size) {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getSize() <= size;
            }
        });
    }
    public void preferMarketSizeAtMost(final int size) {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getSize() <= size;
            }
        });
    }
    
    public void requireMarketStabilityAtLeast(final int stability) {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getStabilityValue() >= stability;
            }
        });
    }
    public void preferMarketStabilityAtLeast(final int stability) {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getStabilityValue() >= stability;
            }
        });
    }
    public void requireMarketStabilityAtMost(final int stability) {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getStabilityValue() <= stability;
            }
        });
    }
    public void preferMarketStabilityAtMost(final int stability) {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.getStabilityValue() <= stability;
            }
        });
    }
    
    public void requireMarketConditions(ReqMode mode, String ... conditions) {
        search.marketReqs.add(new RequiredMarketConditions(mode, conditions));
    }
    public void preferMarketConditions(ReqMode mode, String ... conditions) {
        search.marketPrefs.add(new RequiredMarketConditions(mode, conditions));
    }
    
    public void requireMarketIndustries(ReqMode mode, String ... industries) {
        search.marketReqs.add(new RequiredMarketIndustries(mode, industries));
    }
    public void preferMarketIndustries(ReqMode mode, String ... industries) {
        search.marketPrefs.add(new RequiredMarketIndustries(mode, industries));
    }
    
    public void requireMarketIsMilitary() {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return Misc.isMilitary(market);
            }
        });
    }
    public void preferMarketIsMilitary() {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return Misc.isMilitary(market);
            }
        });
    }
    
    public void requireMarketHasSpaceport() {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.hasSpaceport();
            }
        });
    }
    public void preferMarketHasSpaceport() {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return market.hasSpaceport();
            }
        });
    }
    
    public void requireMarketNotHasSpaceport() {
        search.marketReqs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return !market.hasSpaceport();
            }
        });
    }
    public void preferMarketNotHasSpaceport() {
        search.marketPrefs.add(new MarketRequirement() {
            public boolean marketMatchesRequirement(MarketAPI market) {
                return !market.hasSpaceport();
            }
        });
    }
    
    public void requireCommodityIsNotPersonnel() {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return !com.isPersonnel();
            }
        });
    }
    public void preferCommodityIsNotPersonnel() {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return !com.isPersonnel();
            }
        });
    }
    
    public void requireCommodityLegal() {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return !com.isIllegal();
            }
        });
    }
    public void preferCommodityLegal() {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return !com.isIllegal();
            }
        });
    }
    public void requireCommodityIllegal() {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.isIllegal();
            }
        });
    }
    public void preferCommodityIllegal() {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.isIllegal();
            }
        });
    }
    
    public void requireCommodityIs(final String id) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getId().equals(id);
            }
        });
    }
    public void preferCommodityIs(final String id) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getId().equals(id);
            }
        });
    }
    
    public void requireCommodityTags(ReqMode mode, String ... tags) {
        search.commodityReqs.add(new RequiredCommodityTags(mode, tags));
    }
    public void preferCommodityTags(ReqMode mode, String ... tags) {
        search.commodityPrefs.add(new RequiredCommodityTags(mode, tags));
    }
    
    public void requireCommodityAvailableAtLeast(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getAvailable() >= qty;
            }
        });
    }
    public void preferCommodityAvailableAtLeast(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getAvailable() >= qty;
            }
        });
    }
    public void requireCommodityAvailableAtMost(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getAvailable() <= qty;
            }
        });
    }
    public void preferCommodityAvailableAtMost(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getAvailable() <= qty;
            }
        });
    }
    
    public void requireCommodityDemandAtLeast(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxDemand() >= qty;
            }
        });
    }
    public void preferCommodityDemandAtLeast(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxDemand() >= qty;
            }
        });
    }
    public void requireCommodityDemandAtMost(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxDemand() <= qty;
            }
        });
    }
    public void preferCommodityDemandAtMost(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxDemand() <= qty;
            }
        });
    }
    
    public void requireCommodityProductionAtLeast(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxSupply() >= qty;
            }
        });
    }
    public void preferCommodityProductionAtLeast(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxSupply() >= qty;
            }
        });
    }
    public void requireCommodityProductionAtMost(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxSupply() <= qty;
            }
        });
    }
    public void preferCommodityProductionAtMost(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getMaxSupply() <= qty;
            }
        });
    }
    
    public void requireCommoditySurplusAtLeast(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.extra >= qty;
            }
        });
    }
    public void preferCommoditySurplusAtLeast(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.extra >= qty;
            }
        });
    }
    public void requireCommoditySurplusAtMost(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.extra <= qty;
            }
        });
    }
    public void preferCommoditySurplusAtMost(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.extra <= qty;
            }
        });
    }
    
    public void requireCommodityDeficitAtLeast(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.deficit >= qty;
            }
        });
    }
    public void preferCommodityDeficitAtLeast(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.deficit >= qty;
            }
        });
    }
    public void requireCommodityDeficitAtMost(final int qty) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.deficit <= qty;
            }
        });
    }
    public void preferCommodityDeficitAtMost(final int qty) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                CommodityIconCounts counts = new CommodityIconCounts(com);
                return counts.deficit <= qty;
            }
        });
    }
    
    public void requireCommodityBasePriceAtLeast(final float price) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getCommodity().getBasePrice() >= price;
            }
        });
    }
    public void preferCommodityBasePriceAtLeast(final float price) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getCommodity().getBasePrice() >= price;
            }
        });
    }
    public void requireCommodityBasePriceAtMost(final float price) {
        search.commodityReqs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getCommodity().getBasePrice() <= price;
            }
        });
    }
    public void preferCommodityBasePriceAtMost(final float price) {
        search.commodityPrefs.add(new CommodityRequirement() {
            public boolean commodityMatchesRequirement(CommodityOnMarketAPI com) {
                return com.getCommodity().getBasePrice() <= price;
            }
        });
    }
 
    public void requireTerrainType(ReqMode mode, String ... types) {
        search.terrainReqs.add(new TerrainTypeReq(mode, types));
    }
    public void preferTerrainType(ReqMode mode, String ... types) {
        search.terrainPrefs.add(new TerrainTypeReq(mode, types));
    }
    
    public void requireTerrainTags(ReqMode mode, String ... tags) {
        search.terrainReqs.add(new RequiredTerrainTags(mode, tags));
    }
    public void preferTerrainTags(ReqMode mode, String ... tags) {
        search.terrainPrefs.add(new RequiredTerrainTags(mode, tags));
    }
    public void requireTerrainHasSpecialName() {
        search.terrainReqs.add(new TerrainHasSpecialNameReq());
    }
    public void preferTerrainHasSpecialName() {
        search.terrainPrefs.add(new TerrainHasSpecialNameReq());
    }
    
    public CampaignTerrainAPI pickTerrain() {
        return pickTerrain(true);
    }
    public CampaignTerrainAPI pickTerrain(boolean resetSearch) {
        findMatchingSystems();
        
        List<CampaignTerrainAPI> inPreferredSystems = new ArrayList<CampaignTerrainAPI>();
        List<CampaignTerrainAPI> inMatchingSystems = new ArrayList<CampaignTerrainAPI>();
        for (StarSystemAPI system : search.matchingSystems) {
            List<CampaignTerrainAPI> terrainList = new ArrayList<CampaignTerrainAPI>(system.getTerrainCopy());
            for (CampaignTerrainAPI terrain : terrainList) {
                if (terrain.hasTag(Tags.EXPIRES)) continue;
                
                // exclude system-wide nebulas
                if (terrain.getPlugin() instanceof BaseTiledTerrain) {
                    BaseTiledTerrain btt = (BaseTiledTerrain) terrain.getPlugin();
                    if (btt.getTiles() != null && btt.getTiles().length > 50) continue;
                }
                // exclude large rings
                if (terrain.getPlugin() instanceof BaseRingTerrain) {
                    BaseRingTerrain rtp = (BaseRingTerrain) terrain.getPlugin();
                    if (rtp.getRingParams() != null && rtp.getRingParams().middleRadius > 5000f) continue;
                }
                inMatchingSystems.add(terrain);
            }
        }
        for (StarSystemAPI system : search.preferredSystems) {
            List<CampaignTerrainAPI> terrainList = new ArrayList<CampaignTerrainAPI>(system.getTerrainCopy());
            for (CampaignTerrainAPI terrain : terrainList) {
                if (terrain.hasTag(Tags.EXPIRES)) continue;
                
                // exclude system-wide nebulas
                if (terrain.getPlugin() instanceof BaseTiledTerrain) {
                    BaseTiledTerrain btt = (BaseTiledTerrain) terrain.getPlugin();
                    if (btt.getTiles() != null && btt.getTiles().length > 50) continue;
                }
                // exclude large rings
                if (terrain.getPlugin() instanceof BaseRingTerrain) {
                    BaseRingTerrain rtp = (BaseRingTerrain) terrain.getPlugin();
                    if (rtp.getRingParams() != null && rtp.getRingParams().middleRadius > 5000f) continue;
                }
                inMatchingSystems.add(terrain);
            }
        }
            
        List<CampaignTerrainAPI> matchesInPref = new ArrayList<CampaignTerrainAPI>();
        List<CampaignTerrainAPI> preferredInPref = new ArrayList<CampaignTerrainAPI>();
        findMatching(search.terrainReqs, search.terrainPrefs, inPreferredSystems, matchesInPref, preferredInPref);
        if (!preferredInPref.isEmpty()) {
            if (resetSearch) resetSearch();
            return (CampaignTerrainAPI) pickOneObject(preferredInPref);
        }
        List<CampaignTerrainAPI> matchesInMatches = new ArrayList<CampaignTerrainAPI>();
        List<CampaignTerrainAPI> preferredInMatches = new ArrayList<CampaignTerrainAPI>();
        findMatching(search.terrainReqs, search.terrainPrefs, inMatchingSystems, matchesInMatches, preferredInMatches);
        if (makeSystemPreferencesMoreImportant) {
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (CampaignTerrainAPI) pickOneObject(matchesInPref);
            }
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (CampaignTerrainAPI) pickOneObject(preferredInMatches);
            }
        } else {
            if (!preferredInMatches.isEmpty()) {
                if (resetSearch) resetSearch();
                return (CampaignTerrainAPI) pickOneObject(preferredInMatches);
            }
            if (!matchesInPref.isEmpty()) {
                if (resetSearch) resetSearch();
                return (CampaignTerrainAPI) pickOneObject(matchesInPref);
            }
        }
        
        if (resetSearch) resetSearch();
        return (CampaignTerrainAPI) pickOneObject(matchesInMatches);
        
        
        
        
//      WeightedRandomPicker<StarSystemAPI> pref = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      WeightedRandomPicker<StarSystemAPI> other = new WeightedRandomPicker<StarSystemAPI>(genRandom);
//      pref.addAll(search.preferredSystems);
//      other.addAll(search.matchingSystems);
//      
//      WeightedRandomPicker<CampaignTerrainAPI> allMatches = new WeightedRandomPicker<CampaignTerrainAPI>(genRandom);
//      while (!pref.isEmpty() || !other.isEmpty()) {
//          StarSystemAPI pick = pref.pickAndRemove();
//          if (pick == null) pick = other.pickAndRemove();
//          if (pick == null) break;
//          
//          WeightedRandomPicker<CampaignTerrainAPI> matches = new WeightedRandomPicker<CampaignTerrainAPI>(genRandom);
//          
//          List<CampaignTerrainAPI> terrainList = new ArrayList<CampaignTerrainAPI>(pick.getTerrainCopy());
//          WeightedRandomPicker<CampaignTerrainAPI> preferred = new WeightedRandomPicker<CampaignTerrainAPI>(genRandom);
//          OUTER: for (CampaignTerrainAPI terrain : terrainList) {
//              if (terrain.hasTag(Tags.EXPIRES)) continue;
//              for (TerrainRequirement req : search.terrainReqs) {
//                  if (!req.terrainMatchesRequirement(terrain)) continue OUTER;
//              }
//              allMatches.add(terrain);
//              matches.add(terrain);
//          }
//          
//          
//          List<CampaignTerrainAPI> matchingPrefs = new ArrayList<CampaignTerrainAPI>(matches.getItems());
//          boolean foundAny = false;
//          for (TerrainRequirement req : search.terrainPrefs) {
//              List<CampaignTerrainAPI> retain = new ArrayList<CampaignTerrainAPI>();
//              for (CampaignTerrainAPI curr : matchingPrefs) {
//                  if (curr.hasTag(Tags.EXPIRES)) continue;
//                  if (req.terrainMatchesRequirement(curr)) {
//                      retain.add(curr);
//                  }
//              }
//              if (retain.isEmpty()) continue;
//              foundAny = true;
//              matchingPrefs.retainAll(retain);
//          }
//          if (foundAny) {
//              preferred.addAll(matchingPrefs);
//          }
//          
//          if (!preferred.isEmpty()) {
//              if (resetSearch) resetSearch();
//              return preferred.pick();
//          }
//      }
//      
//      if (resetSearch) resetSearch();
//      return allMatches.pick();
    }
}