HubMissionWithTriggers.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.EnumSet;
import java.util.List;
import java.util.Random;
 
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.EveryFrameScript;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.Script;
import com.fs.starfarer.api.campaign.CampaignFleetAPI;
import com.fs.starfarer.api.campaign.CargoAPI;
import com.fs.starfarer.api.campaign.FactionAPI;
import com.fs.starfarer.api.campaign.FactionAPI.ShipPickMode;
import com.fs.starfarer.api.campaign.FactionAPI.ShipPickParams;
import com.fs.starfarer.api.campaign.FactionDoctrineAPI;
import com.fs.starfarer.api.campaign.FleetInflater;
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.SpecialItemData;
import com.fs.starfarer.api.campaign.StarSystemAPI;
import com.fs.starfarer.api.campaign.econ.CommoditySpecAPI;
import com.fs.starfarer.api.campaign.econ.MarketAPI;
import com.fs.starfarer.api.campaign.rules.HasMemory;
import com.fs.starfarer.api.campaign.rules.MemoryAPI;
import com.fs.starfarer.api.characters.AbilityPlugin;
import com.fs.starfarer.api.characters.PersonAPI;
import com.fs.starfarer.api.combat.ShipVariantAPI;
import com.fs.starfarer.api.fleet.FleetMemberAPI;
import com.fs.starfarer.api.fleet.ShipRolePick;
import com.fs.starfarer.api.impl.campaign.DerelictShipEntityPlugin.DerelictShipData;
import com.fs.starfarer.api.impl.campaign.DerelictShipEntityPlugin.DerelictType;
import com.fs.starfarer.api.impl.campaign.fleets.DefaultFleetInflater;
import com.fs.starfarer.api.impl.campaign.fleets.DefaultFleetInflaterParams;
import com.fs.starfarer.api.impl.campaign.fleets.FleetFactoryV3;
import com.fs.starfarer.api.impl.campaign.fleets.FleetParamsV3;
import com.fs.starfarer.api.impl.campaign.ids.Abilities;
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.FleetTypes;
import com.fs.starfarer.api.impl.campaign.ids.MemFlags;
import com.fs.starfarer.api.impl.campaign.ids.ShipRoles;
import com.fs.starfarer.api.impl.campaign.ids.Skills;
import com.fs.starfarer.api.impl.campaign.missions.hub.MissionTrigger.TriggerAction;
import com.fs.starfarer.api.impl.campaign.missions.hub.MissionTrigger.TriggerActionContext;
import com.fs.starfarer.api.impl.campaign.procgen.StarSystemGenerator;
import com.fs.starfarer.api.impl.campaign.procgen.themes.RemnantSeededFleetManager;
import com.fs.starfarer.api.impl.campaign.procgen.themes.SalvageSpecialAssigner;
import com.fs.starfarer.api.impl.campaign.rulecmd.salvage.special.BaseSalvageSpecial;
import com.fs.starfarer.api.impl.campaign.rulecmd.salvage.special.TransmitterTrapSpecial;
import com.fs.starfarer.api.impl.campaign.skills.OfficerTraining;
import com.fs.starfarer.api.impl.campaign.terrain.StarCoronaTerrainPlugin;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.util.WeightedRandomPicker;
 
public abstract class HubMissionWithTriggers extends BaseHubMission {
    
    public static enum FleetSize {
        TINY(0.06f),
        VERY_SMALL(0.1f),
        SMALL(0.2f),
        MEDIUM(0.35f),
        LARGE(0.5f),
        LARGER(0.6f),
        VERY_LARGE(0.7f),
        HUGE(0.9f),
        MAXIMUM(1.1f);
        
        public float maxFPFraction;
        private FleetSize(float maxFPFraction) {
            this.maxFPFraction = maxFPFraction;
        }
        
        private static FleetSize [] vals = values();
        public FleetSize next() {
            int index = this.ordinal() + 1;
            if (index >= vals.length) index = vals.length - 1;
            return vals[index];
        }
        public FleetSize prev() {
            int index = this.ordinal() - 1;
            if (index < 0) index = 0;
            return vals[index];
        }
    }
    
    public static enum FleetQuality {
        VERY_LOW(-1f, 0),
        LOWER(-0.5f, 0),
        DEFAULT(0f, 0),
        HIGHER(0.5f, 0),
        VERY_HIGH(1f, 0),
        SMOD_1(1.5f, 1),
        SMOD_2(1.5f, 2),
        SMOD_3(1.5f, 3);
        
        
        public float qualityMod;
        public int numSMods;
        private FleetQuality(float qualityMod, int numSMods) {
            this.qualityMod = qualityMod;
            this.numSMods = numSMods;
        }
        
        private static FleetQuality [] vals = values();
        public FleetQuality next() {
            int index = this.ordinal() + 1;
            if (index >= vals.length) index = vals.length - 1;
            return vals[index];
        }
        public FleetQuality prev() {
            int index = this.ordinal() - 1;
            if (index < 0) index = 0;
            return vals[index];
        }
    }
    
    public static enum OfficerNum {
        NONE,
        FC_ONLY,
        FEWER,
        DEFAULT,
        MORE,
        ALL_SHIPS;
        
        private static OfficerNum [] vals = values();
        public OfficerNum next() {
            int index = this.ordinal() + 1;
            if (index >= vals.length) index = vals.length - 1;
            return vals[index];
        }
        public OfficerNum prev() {
            int index = this.ordinal() - 1;
            if (index < 0) index = 0;
            return vals[index];
        }
    }
    
    public static enum OfficerQuality {
        LOWER,
        DEFAULT,
        HIGHER,
        UNUSUALLY_HIGH, 
        AI_GAMMA,
        AI_BETA,
        AI_BETA_OR_GAMMA,
        AI_ALPHA,
        AI_OMEGA, 
        AI_MIXED;
        
        private static OfficerQuality [] vals = values();
        public OfficerQuality next() {
            int index = this.ordinal() + 1;
            if (index >= vals.length) index = vals.length - 1;
            return vals[index];
        }
        public OfficerQuality prev() {
            int index = this.ordinal() - 1;
            if (index < 0) index = 0;
            return vals[index];
        }
    }
    
    public static class FleetAddTugs implements TriggerAction {
        int numTugs = 0;
        public FleetAddTugs(int numTugs) {
            this.numTugs = numTugs;
        }
        public void doAction(TriggerActionContext context) {
            if (context.fleet != null) {
                addTugsToFleet(context.fleet, numTugs, ((BaseHubMission)context.mission).genRandom);
            }
        }
    }
    
    public static class UnhideCommListing implements TriggerAction {
        protected PersonAPI person;
        public UnhideCommListing(PersonAPI person) {
            this.person = person;
        }
 
        public void doAction(TriggerActionContext context) {
            if (person.getMarket() != null) {
                MarketAPI market = person.getMarket();
                if (market.getCommDirectory().getEntryForPerson(person) == null) {
                    market.getCommDirectory().addPerson(person);
                }
                if (market.getCommDirectory().getEntryForPerson(person) != null) {
                    market.getCommDirectory().getEntryForPerson(person).setHidden(false);
                }
            }
        }
    }
    
    public static class HideCommListing implements TriggerAction {
        protected PersonAPI person;
        public HideCommListing(PersonAPI person) {
            this.person = person;
        }
 
        public void doAction(TriggerActionContext context) {
            if (person.getMarket() != null) {
                MarketAPI market = person.getMarket();
                if (market.getCommDirectory().getEntryForPerson(person) == null) {
                    market.getCommDirectory().addPerson(person);
                }
                if (market.getCommDirectory().getEntryForPerson(person) != null) {
                    market.getCommDirectory().getEntryForPerson(person).setHidden(true);
                }
            }
        }
    }
    
    public static class MovePersonToMarket implements TriggerAction {
        protected PersonAPI person;
        protected MarketAPI market;
        protected boolean alwaysAddToComms;
        
        public MovePersonToMarket(PersonAPI person, MarketAPI market, boolean alwaysAddToComms) {
            super();
            this.person = person;
            this.market = market;
            this.alwaysAddToComms = alwaysAddToComms;
        }
 
 
        public void doAction(TriggerActionContext context) {
            Misc.moveToMarket(person, market, alwaysAddToComms);
        }
    }
    
    
    public static class DespawnEntityAction implements TriggerAction {
        protected SectorEntityToken entity;
        public DespawnEntityAction(SectorEntityToken entity) {
            this.entity = entity;
        }
 
        public void doAction(TriggerActionContext context) {
            Misc.fadeAndExpire(entity);
        }
    }
    
    public static class MakeDiscoverableAction implements TriggerAction {
        protected float range;
        protected float xp;
        public MakeDiscoverableAction(float range, float xp) {
            this.range = range;
            this.xp = xp;
        }
        
        public void doAction(TriggerActionContext context) {
            ((BaseHubMission)context.mission).makeDiscoverable(context.entity, range, xp);
            
        }
    }
    
    //public void spawnShipGraveyard(String factionId, int minShips, int maxShips, LocData data) {
    public static class SpawnShipGraveyardAction implements TriggerAction {
        protected String factionId;
        protected int minShips;
        protected int maxShips;
        protected LocData data;
        public SpawnShipGraveyardAction(String factionId, int minShips, int maxShips, LocData data) {
            this.factionId = factionId;
            this.minShips = minShips;
            this.maxShips = maxShips;
            this.data = data;
        }
        
        public void doAction(TriggerActionContext context) {
            ((BaseHubMission)context.mission).spawnShipGraveyard(factionId, minShips, maxShips, data); 
        }
        
    }
    public static class SpawnDebrisFieldAction implements TriggerAction {
        protected float radius;
        protected float density;
        protected LocData data;
        
        public SpawnDebrisFieldAction(float radius, float density, LocData data) {
            this.radius = radius;
            this.density = density;
            this.data = data;
        }
 
        public void doAction(TriggerActionContext context) {
            SectorEntityToken entity = ((BaseHubMission)context.mission).spawnDebrisField(radius, density, data); 
            context.entity = entity;
        }
    }
    
    
    public static class SpawnEntityAction implements TriggerAction {
        protected String entityId;
        protected LocData data;
 
        public SpawnEntityAction(String entityId, LocData data) {
            this.entityId = entityId;
            this.data = data;
        }
 
        public void doAction(TriggerActionContext context) {
            SectorEntityToken entity = ((BaseHubMission)context.mission).spawnEntity(entityId, data);
            context.entity = entity;
        }
    }
    
    public static class SpawnDerelictAction implements TriggerAction {
        protected String hullId;
        protected String factionId;
        protected DerelictType type;
        protected DerelictShipData shipData;
        protected LocData data;
        
        public SpawnDerelictAction(String hullId, String factionId, DerelictType type, LocData data) {
            this.hullId = hullId;
            this.factionId = factionId;
            this.data = data;
            this.type = type;
        }
        
        public SpawnDerelictAction(DerelictType type, LocData data) {
            this.data = data;
            this.type = type;
        }
        public SpawnDerelictAction(DerelictShipData shipData, LocData data) {
            this.shipData = shipData;
            this.data = data;
        }
        
        public void doAction(TriggerActionContext context) {
            SectorEntityToken entity = null;
            if (hullId != null) {
                entity = ((BaseHubMission)context.mission).spawnDerelictHull(hullId, data);
            } else if (factionId != null) {
                entity = ((BaseHubMission)context.mission).spawnDerelict(factionId, type, data);
            } else if (shipData != null) {
                entity = ((BaseHubMission)context.mission).spawnDerelict(shipData, data);
            } else {
                entity = ((BaseHubMission)context.mission).spawnDerelictOfType(type, data);
            }
            context.entity = entity;
        }
    }
 
    
 
    public static class SpawnFleetNearAction implements TriggerAction {
        protected SectorEntityToken entity;
        protected float range;
 
        public SpawnFleetNearAction(SectorEntityToken entity, float range) {
            this.entity = entity;
            this.range = range;
        }
 
        public void doAction(TriggerActionContext context) {
            entity.getContainingLocation().addEntity(context.fleet);
            Vector2f loc = Misc.getPointWithinRadius(entity.getLocation(), range);
            context.fleet.setLocation(loc.x, loc.y);
        }
    }
    public static class SetFleetFactionAction implements TriggerAction {
        protected String factionId;
 
        public SetFleetFactionAction(String factionId) {
            this.factionId = factionId;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.setFaction(factionId, true);
        }
    }
    
    public static class SetEntityToPickedJumpPoint implements TriggerAction {
        public SetEntityToPickedJumpPoint() {
        }
        
        public void doAction(TriggerActionContext context) {
            context.entity = context.jumpPoint;
        }
    }
 
    public static class FleetMakeImportantAction implements TriggerAction {
        protected String flag;
        protected Enum[] stages;
        public FleetMakeImportantAction(String flag, Enum ... stages) {
            this.flag = flag;
            this.stages = stages;
        }
        public void doAction(TriggerActionContext context) {
            BaseHubMission bhm = (BaseHubMission) context.mission;
            bhm.makeImportant(context.fleet, flag, stages);
            
            if (stages != null && Arrays.asList(stages).contains(bhm.getCurrentStage())) {
                Misc.makeImportant(context.fleet.getMemoryWithoutUpdate(), bhm.getReason());
                bhm.changes.add(new MadeImportant(context.fleet.getMemoryWithoutUpdate(), bhm.getReason()));
                
                if (flag != null) {
                    context.fleet.getMemoryWithoutUpdate().set(flag, true);
                    bhm.changes.add(new VariableSet(context.fleet.getMemoryWithoutUpdate(), flag, true));
                }
            }
//          else if (stages == null) {
//              Misc.makeImportant(context.fleet.getMemoryWithoutUpdate(), bhm.getReason());
//          }
            
//          if (context.mission instanceof BaseHubMission) {
//              Misc.makeImportant(context.fleet.getMemoryWithoutUpdate(), reason);
//              BaseHubMission bhm = (BaseHubMission) context.mission;
//              bhm.changes.add(new MadeImportant(context.fleet.getMemoryWithoutUpdate(), reason));
//          }
        }
    }
    
    public static class EntityMakeImportantAction implements TriggerAction {
        protected String flag;
        protected Enum[] stages;
        public EntityMakeImportantAction(String flag, Enum ... stages) {
            this.flag = flag;
            this.stages = stages;
        }
        public void doAction(TriggerActionContext context) {
            BaseHubMission bhm = (BaseHubMission) context.mission;
            bhm.makeImportant(context.entity, flag, stages);
            
            if (Arrays.asList(stages).contains(bhm.getCurrentStage())) {
                Misc.makeImportant(context.entity.getMemoryWithoutUpdate(), bhm.getReason());
                bhm.changes.add(new MadeImportant(context.entity.getMemoryWithoutUpdate(), bhm.getReason()));
                
                if (flag != null) {
                    context.entity.getMemoryWithoutUpdate().set(flag, true);
                    bhm.changes.add(new VariableSet(context.entity.getMemoryWithoutUpdate(), flag, true));
                }
            }
            
//          if (context.mission instanceof BaseHubMission) {
//              Misc.makeImportant(context.entity.getMemoryWithoutUpdate(), reason);
//              BaseHubMission bhm = (BaseHubMission) context.mission;
//              bhm.changes.add(new MadeImportant(context.entity.getMemoryWithoutUpdate(), reason));
//          }
        }
    }
 
    public static class SetFleetFlagsWithReasonAction implements TriggerAction {
        protected String[] flags;
        protected String reason;
        protected boolean permanent;
 
        public SetFleetFlagsWithReasonAction(String reason, boolean permanent, String ... flags) {
            this.permanent = permanent;
            this.flags = flags;
            this.reason = reason;
        }
 
        public void doAction(TriggerActionContext context) {
            BaseHubMission bhm = (BaseHubMission) context.mission;
            for (String flag : flags) {
                Misc.setFlagWithReason(context.fleet.getMemoryWithoutUpdate(),
                                       flag, reason, true, -1f);
                
                if (context.makeAllFleetFlagsPermanent) {
                    permanent = true;
                }
                
                if (!permanent && bhm != null) {
                    String requiredKey = flag + "_" + reason;
                    bhm.changes.add(new VariableSet(context.fleet.getMemoryWithoutUpdate(), requiredKey, true));
                }
            }
        }
    }
 
    public static class UnsetFleetFlagsWithReasonAction implements
            TriggerAction {
        protected String[] flags;
        protected String reason;
 
        public UnsetFleetFlagsWithReasonAction(String reason, String ... flags) {
            this.reason = reason;
            this.flags = flags;
        }
 
        public void doAction(TriggerActionContext context) {
            for (String flag : flags) {
                Misc.setFlagWithReason(context.fleet.getMemoryWithoutUpdate(),
                        flag, reason, false, -1f);
            }
        }
    }
 
 
    public static class SetPersonMissionRefAction implements TriggerAction {
        protected String key;
 
        public SetPersonMissionRefAction(String key) {
            this.key = key;
        }
 
        public void doAction(TriggerActionContext context) {
            context.person.getMemoryWithoutUpdate().set(key, context.mission);
        }
    }
 
 
    public static class SetFleetMissionRefAction implements TriggerAction {
        protected String key;
 
        public SetFleetMissionRefAction(String key) {
            this.key = key;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.getMemoryWithoutUpdate().set(key, context.mission);
        }
    }
 
 
    public static class SetMemoryValueAction implements TriggerAction {
        protected String key;
        protected Object value;
        protected MemoryAPI memory;
        protected boolean removeOnMissionOver;
        
        public SetMemoryValueAction(MemoryAPI memory, String key, Object value, boolean removeOnMissionOver) {
            this.memory = memory;
            this.key = key;
            this.value = value;
            this.removeOnMissionOver = removeOnMissionOver;
        }
        
        public void doAction(TriggerActionContext context) {
            memory.set(key, value);
            BaseHubMission bhm = (BaseHubMission) context.mission;
            bhm.changes.add(new VariableSet(memory, key, removeOnMissionOver));
        }
    }
    
    public static class SetMemoryValueAfterDelay implements TriggerAction, EveryFrameScript {
        protected String key;
        protected Object value;
        protected MemoryAPI memory;
        protected float delay;
        
        public SetMemoryValueAfterDelay(float delay, MemoryAPI memory, String key, Object value) {
            this.memory = memory;
            this.key = key;
            this.value = value;
            this.delay = delay;
        }
        
        public void doAction(TriggerActionContext context) {
            if (delay <= 0) {
                memory.set(key, value);
            } else {
                Global.getSector().addScript(this);
            }
        }
 
        public boolean isDone() {
            return delay < 0;
        }
 
        public boolean runWhilePaused() {
            return false;
        }
 
        public void advance(float amount) {
            if (delay < 0) return; 
            float days = Global.getSector().getClock().convertToDays(amount);
            delay -= days;
            if (delay < 0) {
                memory.set(key, value);
            }
        }
    }
    
    public static class AddTagAfterDelay implements TriggerAction, EveryFrameScript {
        protected String tag;
        protected float delay;
        protected StarSystemAPI system;
        
        public AddTagAfterDelay(float delay, StarSystemAPI system, String tag) {
            this.delay = delay;
            this.system = system;
            this.tag = tag;
        }
        
        public void doAction(TriggerActionContext context) {
            Global.getSector().addScript(this);
        }
        
        public boolean isDone() {
            return delay < 0;
        }
        
        public boolean runWhilePaused() {
            return false;
        }
        
        public void advance(float amount) {
            if (delay < 0) return; 
            float days = Global.getSector().getClock().convertToDays(amount);
            delay -= days;
            if (delay < 0) {
                system.addTag(tag);
            }
        }
    }
    
    public static class RunScriptAfterDelay implements TriggerAction, EveryFrameScript {
        protected float delay;
        protected Script script;
        
        public RunScriptAfterDelay(float delay, Script script) {
            this.script = script;
            this.delay = delay;
        }
        
        public void doAction(TriggerActionContext context) {
            Global.getSector().addScript(this);
        }
        
        public boolean isDone() {
            return delay < 0;
        }
        
        public boolean runWhilePaused() {
            return false;
        }
        
        public void advance(float amount) {
            if (delay < 0) return; 
            float days = Global.getSector().getClock().convertToDays(amount);
            delay -= days;
            if (delay < 0 && script != null) {
                script.run();
                script = null;
            }
        }
    }
    
    public static class IncreaseMarketHostileTimeout implements TriggerAction {
        protected MarketAPI market;
        protected float days;
        
        public IncreaseMarketHostileTimeout(MarketAPI market, float days) {
            this.market = market;
            this.days = days;
        }
 
        public void doAction(TriggerActionContext context) {
            Misc.increaseMarketHostileTimeout(market, days);
        }
    }
    
    public static class SetFleetMemoryValueAction implements TriggerAction {
        protected String key;
        protected Object value;
 
        public SetFleetMemoryValueAction(String key, Object value) {
            this.key = key;
            this.value = value;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.getMemoryWithoutUpdate().set(key, value);
        }
    }
    
    public static class AddFleetDefeatTriggerAction implements TriggerAction {
        protected String trigger;
        protected boolean permanent;
        public AddFleetDefeatTriggerAction(String trigger, boolean permanent) {
            this.trigger = trigger;
            this.permanent = permanent;
        }
        public void doAction(TriggerActionContext context) {
            ((BaseHubMission)context.mission).addFleetDefeatTrigger(context.fleet, trigger, permanent);
        }
    }
    
    public static class MakeFleetFlagsPermanentAction implements TriggerAction {
        protected boolean permanent;
        public MakeFleetFlagsPermanentAction(boolean permanent) {
            this.permanent = permanent;
        }
        public void doAction(TriggerActionContext context) {
            context.makeAllFleetFlagsPermanent = permanent;
        }
    }
 
 
    public static class AddTagsAction implements TriggerAction {
        protected String [] tags;
        
        public AddTagsAction(String ... tags) {
            this.tags = tags;
        }
        
        public void doAction(TriggerActionContext context) {
            for (String tag : tags) {
                context.fleet.addTag(tag);
            }
        }
    }
    
    public static class AddCommanderSkillAction implements TriggerAction {
        protected String skill;
        protected int level;
        
        public AddCommanderSkillAction(String skill, int level) {
            this.skill = skill;
            this.level = level;
        }
        
        public void doAction(TriggerActionContext context) {
            context.fleet.getCommanderStats().setSkillLevel(skill, level);
        }
    }
    
    public static class SetFleetFlagAction implements TriggerAction {
        protected String flag;
        protected Object[] stages;
        protected boolean permanent;
 
        public SetFleetFlagAction(String flag, boolean permanent, Object ... stages) {
            this.flag = flag;
            this.permanent = permanent;
            this.stages = stages;
        }
 
        public void doAction(TriggerActionContext context) {
            if (context.makeAllFleetFlagsPermanent) {
                permanent = true;
            }
            ((BaseHubMission)context.mission).setFlag(context.fleet, flag, permanent, stages);
        }
    }
    
    public static class SetEntityFlagAction implements TriggerAction {
        protected String flag;
        protected Object[] stages;
        protected boolean permanent;
 
        public SetEntityFlagAction(String flag, boolean permanent, Object ... stages) {
            this.flag = flag;
            this.permanent = permanent;
            this.stages = stages;
        }
 
        public void doAction(TriggerActionContext context) {
            ((BaseHubMission)context.mission).setFlag(context.entity, flag, permanent, stages);
        }
    }
 
 
    public static class UnsetFleetFlagsAction implements TriggerAction {
        protected String[] flags;
 
        public UnsetFleetFlagsAction(String ... flags) {
            this.flags = flags;
        }
 
        public void doAction(TriggerActionContext context) {
            for (String flag : flags) {
                context.fleet.getMemoryWithoutUpdate().unset(flag);
            }
        }
    }
    
    public static class UnsetEntityFlagsAction implements TriggerAction {
        protected String[] flags;
        
        public UnsetEntityFlagsAction(String ... flags) {
            this.flags = flags;
        }
        
        public void doAction(TriggerActionContext context) {
            for (String flag : flags) {
                context.entity.getMemoryWithoutUpdate().unset(flag);
            }
        }
    }
 
 
    public static class SaveEntityReferenceAction implements TriggerAction {
        protected MemoryAPI memory;
        protected String key;
        public SaveEntityReferenceAction(MemoryAPI memory, String key) {
            this.memory = memory;
            this.key = key;
        }
        
        public void doAction(TriggerActionContext context) {
            memory.set(key, context.entity);
            ((BaseHubMission) context.mission).changes.add(new VariableSet(memory, key, true));
        }
    }
    
    public static class SaveFleetReferenceAction implements TriggerAction {
        protected MemoryAPI memory;
        protected String key;
        public SaveFleetReferenceAction(MemoryAPI memory, String key) {
            this.memory = memory;
            this.key = key;
        }
        
        public void doAction(TriggerActionContext context) {
            memory.set(key, context.fleet);
            ((BaseHubMission) context.mission).changes.add(new VariableSet(memory, key, true));
        }
    }
    
    public static class RemoveAbilitiesAction implements TriggerAction {
        protected String[] abilities;
 
        public RemoveAbilitiesAction(String ... abilities) {
            this.abilities = abilities;
        }
 
        public void doAction(TriggerActionContext context) {
            for (String ability : abilities) {
                context.fleet.removeAbility(ability);
            }
        }
    }
 
 
    public static class AddAbilitiesAction implements TriggerAction {
        protected String[] abilities;
 
        public AddAbilitiesAction(String ... abilities) {
            this.abilities = abilities;
        }
 
        public void doAction(TriggerActionContext context) {
            for (String ability : abilities) {
                context.fleet.addAbility(ability);
            }
        }
    }
    
    public static class GenericAddTagsAction implements TriggerAction {
        protected String [] tags;
        protected SectorEntityToken entity;
        
        public GenericAddTagsAction(SectorEntityToken entity, String ... tags) {
            this.tags = tags;
            this.entity = entity;
        }
        
        public void doAction(TriggerActionContext context) {
            for (String tag : tags) {
                entity.addTag(tag);
            }
        }
    }
    
    public static class GenericRemoveTagsAction implements TriggerAction {
        protected String [] tags;
        protected SectorEntityToken entity;
        
        public GenericRemoveTagsAction(SectorEntityToken entity, String ... tags) {
            this.tags = tags;
            this.entity = entity;
        }
        
        public void doAction(TriggerActionContext context) {
            for (String tag : tags) {
                entity.removeTag(tag);
            }
        }
    }
    
    public static class MakeNonStoryCriticalAction implements TriggerAction {
        protected MemoryAPI [] memoryArray;
 
        public MakeNonStoryCriticalAction(MemoryAPI ... memoryArray) {
            this.memoryArray = memoryArray;
        }
        public void doAction(TriggerActionContext context) {
            BaseHubMission bhm = (BaseHubMission) context.mission;
            for (MemoryAPI memory : memoryArray) {
                Misc.makeNonStoryCritical(memory, bhm.getReason());
            }
        }
    }
 
 
    public static class SetInflaterAction implements TriggerAction {
        protected FleetInflater inflater;
 
        public SetInflaterAction(FleetInflater inflater) {
            this.inflater = inflater;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.setInflater(inflater);
        }
    }
 
 
    public static class SetRemnantConfigAction implements TriggerAction {
        protected boolean dormant;
        protected long seed;
 
        public SetRemnantConfigAction(boolean dormant, long seed) {
            this.dormant = dormant;
            this.seed = seed;
        }
 
        public void doAction(TriggerActionContext context) {
            Random random = new Random(seed);
            RemnantSeededFleetManager.initRemnantFleetProperties(random, context.fleet, dormant);
        }
    }
 
 
    public static class AddCustomDropAction implements TriggerAction {
        protected CargoAPI cargo;
 
        public AddCustomDropAction(CargoAPI cargo) {
            this.cargo = cargo;
        }
 
        public void doAction(TriggerActionContext context) {
            BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
        }
    }
 
 
    public static class AddCommodityDropAction implements TriggerAction {
        protected int quantity;
        protected String commodityId;
        protected boolean dropQuantityBasedOnShipsDestroyed;
 
        public AddCommodityDropAction(int quantity, String commodityId, boolean dropQuantityBasedOnShipsDestroyed) {
            this.quantity = quantity;
            this.commodityId = commodityId;
            this.dropQuantityBasedOnShipsDestroyed = dropQuantityBasedOnShipsDestroyed;
        }
 
        public void doAction(TriggerActionContext context) {
            if (dropQuantityBasedOnShipsDestroyed) {
                context.fleet.getCargo().addCommodity(commodityId, quantity);
            } else {
                CargoAPI cargo = Global.getFactory().createCargo(true);
                cargo.addCommodity(commodityId, quantity);
                BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
            }
        }
    }
    
    public static class AddCommodityFractionDropAction implements TriggerAction {
        protected float fraction;
        protected String commodityId;
        protected boolean dropQuantityBasedOnShipsDestroyed;
        
        public AddCommodityFractionDropAction(float fraction, String commodityId) {
            this.fraction = fraction;
            this.commodityId = commodityId;
        }
        
        public void doAction(TriggerActionContext context) {
            CommoditySpecAPI spec = Global.getSettings().getCommoditySpec(commodityId);
            float capacity = context.fleet.getCargo().getMaxCapacity();
            if (spec.isFuel()) {
                capacity = context.fleet.getCargo().getMaxFuel();
            } else if (spec.isPersonnel()) {
                capacity = context.fleet.getCargo().getMaxPersonnel();
            }
            int quantity = (int) Math.round(fraction * capacity);
            if (quantity > 0) {
                context.fleet.getCargo().addCommodity(commodityId, quantity);
            }
        }
    }
 
 
    public static class AddWeaponDropAction implements TriggerAction {
        protected int quantity;
        protected String weaponId;
 
        public AddWeaponDropAction(int quantity, String weaponId) {
            this.quantity = quantity;
            this.weaponId = weaponId;
        }
 
        public void doAction(TriggerActionContext context) {
            CargoAPI cargo = Global.getFactory().createCargo(true);
            cargo.addWeapons(weaponId, quantity);
            BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
        }
    }
 
 
    public static class AddFighterLPCDropAction implements TriggerAction {
        protected String wingId;
        protected int quantity;
 
        public AddFighterLPCDropAction(String wingId, int quantity) {
            this.wingId = wingId;
            this.quantity = quantity;
        }
 
        public void doAction(TriggerActionContext context) {
            CargoAPI cargo = Global.getFactory().createCargo(true);
            cargo.addFighters(wingId, quantity);
            BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
        }
    }
 
 
    public static class AddHullmodDropAction implements TriggerAction {
        protected String hullmodId;
 
        public AddHullmodDropAction(String hullmodId) {
            this.hullmodId = hullmodId;
        }
 
        public void doAction(TriggerActionContext context) {
            CargoAPI cargo = Global.getFactory().createCargo(true);
            cargo.addHullmods(hullmodId, 1);
            BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
        }
    }
 
 
    public static class AddSpecialItemDropAction implements TriggerAction {
        protected String data;
        protected String itemId;
 
        public AddSpecialItemDropAction(String data, String itemId) {
            this.data = data;
            this.itemId = itemId;
        }
 
        public void doAction(TriggerActionContext context) {
            CargoAPI cargo = Global.getFactory().createCargo(true);
            cargo.addSpecial(new SpecialItemData(itemId, data), 1);
            BaseSalvageSpecial.addExtraSalvage(context.fleet, cargo);
        }
    }
 
 
    public static class SpawnFleetAtPickedLocationAction implements
            TriggerAction {
        protected float range;
 
        public SpawnFleetAtPickedLocationAction(float range) {
            this.range = range;
        }
 
        public void doAction(TriggerActionContext context) {
            context.containingLocation.addEntity(context.fleet);
            Vector2f loc = Misc.getPointWithinRadius(context.coordinates, range);
            context.fleet.setLocation(loc.x, loc.y);
        }
    }
 
 
    public static class PickSetLocationAction implements TriggerAction {
        protected Vector2f coordinates;
        protected LocationAPI location;
 
        public PickSetLocationAction(Vector2f coordinates, LocationAPI location) {
            this.coordinates = coordinates;
            this.location = location;
        }
 
        public void doAction(TriggerActionContext context) {
            context.coordinates = coordinates;
            context.containingLocation = location;
        }
    }
 
 
    public static class PickLocationInHyperspaceAction implements TriggerAction {
        protected StarSystemAPI system;
 
        public PickLocationInHyperspaceAction(StarSystemAPI system) {
            this.system = system;
        }
 
        public void doAction(TriggerActionContext context) {
            //CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, system.getHyperspaceAnchor(), 0, 360f, 2000f, 0f, 1000f);
            
            context.coordinates = pick;
            //context.containingLocation = playerFleet.getContainingLocation();
            context.containingLocation = Global.getSector().getHyperspace();
        }
    }
 
 
    public static class PickLocationTowardsPlayerAction implements TriggerAction {
        protected SectorEntityToken entity;
        protected float arc;
        protected float minDist;
        protected float maxDist;
        protected float minDistFromPlayer;
 
        public PickLocationTowardsPlayerAction(SectorEntityToken entity,
                float arc, float minDist, float maxDist, float minDistFromPlayer) {
            this.entity = entity;
            this.arc = arc;
            this.minDist = minDist;
            this.maxDist = maxDist;
            this.minDistFromPlayer = minDistFromPlayer;
        }
 
        public void doAction(TriggerActionContext context) {
            if (entity == null) entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            
            CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            float dir = Misc.getAngleInDegrees(playerFleet.getLocation(), entity.getLocation());
            dir += 180f;
            if (playerFleet.getContainingLocation() != entity.getContainingLocation()) {
                dir = ((BaseHubMission)context.mission).genRandom.nextFloat() * 360f;
            }
            
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, entity, dir, arc, minDistFromPlayer, minDist, maxDist);
            
            context.coordinates = pick;
            //context.containingLocation = playerFleet.getContainingLocation();
            context.containingLocation = entity.getContainingLocation();
        }
    }
    public static class PickLocationTowardsEntityAction implements TriggerAction {
        protected SectorEntityToken entity;
        protected float arc;
        protected float minDist;
        protected float maxDist;
        protected float minDistFromPlayer;
        
        public PickLocationTowardsEntityAction(SectorEntityToken entity,
                float arc, float minDist, float maxDist, float minDistFromPlayer) {
            this.entity = entity;
            this.arc = arc;
            this.minDist = minDist;
            this.maxDist = maxDist;
            this.minDistFromPlayer = minDistFromPlayer;
        }
        
        public void doAction(TriggerActionContext context) {
            if (entity == null) entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            
            CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            float dir = Misc.getAngleInDegrees(playerFleet.getLocation(), entity.getLocation());
            //dir += 180f;
            if (playerFleet.getContainingLocation() != entity.getContainingLocation()) {
                dir = ((BaseHubMission)context.mission).genRandom.nextFloat() * 360f;
            }
            
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, playerFleet, dir, arc, minDistFromPlayer, minDist, maxDist);
            
            context.coordinates = pick;
            //context.containingLocation = playerFleet.getContainingLocation();
            context.containingLocation = entity.getContainingLocation();
        }
    }
 
 
    public static class PickLocationAwayFromPlayerAction implements
            TriggerAction {
        protected float minDist;
        protected SectorEntityToken entity;
        protected float maxDist;
        protected float arc;
        protected float minDistFromPlayer;
 
        public PickLocationAwayFromPlayerAction(float minDist,
                SectorEntityToken entity, float maxDist, float arc,
                float minDistFromPlayer) {
            this.minDist = minDist;
            this.entity = entity;
            this.maxDist = maxDist;
            this.arc = arc;
            this.minDistFromPlayer = minDistFromPlayer;
        }
 
        public void doAction(TriggerActionContext context) {
            if (entity == null) entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            
            CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            float dir = Misc.getAngleInDegrees(playerFleet.getLocation(), entity.getLocation());
            if (playerFleet.getContainingLocation() != entity.getContainingLocation()) {
                dir = ((BaseHubMission)context.mission).genRandom.nextFloat() * 360f;
            }
            
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, entity, dir, arc, minDistFromPlayer, minDist, maxDist);
            
            context.coordinates = pick;
            //context.containingLocation = playerFleet.getContainingLocation();
            context.containingLocation = entity.getContainingLocation();
        }
    }
 
 
    public static class PickLocationAroundPlayerAction implements TriggerAction {
        protected float maxDist;
        protected float minDist;
 
        public PickLocationAroundPlayerAction(float maxDist, float minDist) {
            this.maxDist = maxDist;
            this.minDist = minDist;
        }
 
        public void doAction(TriggerActionContext context) {
            CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, playerFleet, 0, 360f, minDist, minDist, maxDist);
            
            context.coordinates = pick;
            context.containingLocation = playerFleet.getContainingLocation();
        }
    }
 
 
    public static class PickLocationAroundEntityAction implements TriggerAction {
        protected float minDist;
        protected SectorEntityToken entity;
        protected float maxDist;
        protected float minDistFromPlayer;
 
        public PickLocationAroundEntityAction(float minDist,
                SectorEntityToken entity, float maxDist, float minDistFromPlayer) {
            this.minDist = minDist;
            this.entity = entity;
            this.maxDist = maxDist;
            this.minDistFromPlayer = minDistFromPlayer;
        }
 
        public void doAction(TriggerActionContext context) {
            if (entity == null) entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, entity, 0, 360f, minDistFromPlayer, minDist, maxDist);
            
            context.coordinates = pick;
            context.containingLocation = entity.getContainingLocation();
        }
    }
 
 
    public static class PickLocationWithinArcAction implements TriggerAction {
        protected float arc;
        protected SectorEntityToken entity;
        protected float maxDist;
        protected float minDist;
        protected float minDistFromPlayer;
        protected float dir;
 
        public PickLocationWithinArcAction(float arc, SectorEntityToken entity,
                float maxDist, float minDist, float minDistFromPlayer, float dir) {
            this.arc = arc;
            this.entity = entity;
            this.maxDist = maxDist;
            this.minDist = minDist;
            this.minDistFromPlayer = minDistFromPlayer;
            this.dir = dir;
        }
 
        public void doAction(TriggerActionContext context) {
            if (entity == null) entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            
            Vector2f pick = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, entity, dir, arc, minDistFromPlayer, minDist, maxDist);
            
            context.coordinates = pick;
            context.containingLocation = entity.getContainingLocation();
        }
    }
 
 
    public static class FleetSetPatrolActionText implements TriggerAction {
        protected String text;
        public FleetSetPatrolActionText(String text) {
            this.text = text;
        }
        
        public void doAction(TriggerActionContext context) {
            context.patrolText = text;
        }
    }
    
    public static class FleetSetTravelActionText implements TriggerAction {
        protected String text;
        public FleetSetTravelActionText(String text) {
            this.text = text;
        }
        
        public void doAction(TriggerActionContext context) {
            context.travelText = text;
        }
    }
    
    public static class OrderFleetPatrolSystemAction implements TriggerAction {
        protected StarSystemAPI system;
 
        public OrderFleetPatrolSystemAction(StarSystemAPI system) {
            this.system = system;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.addScript(new TriggerFleetAssignmentAI(context.travelText, context.patrolText, context.mission, system, false, 
                                                                 context.fleet, (SectorEntityToken[])null));
        }
    }
 
 
    public static class OrderFleetPatrolPointsAction implements TriggerAction {
        protected List<SectorEntityToken> patrolPoints;
        protected boolean randomizeLocation;
        protected StarSystemAPI system;
 
        public OrderFleetPatrolPointsAction(SectorEntityToken[] patrolPoints,
                boolean randomizeLocation, StarSystemAPI system) {
            this.patrolPoints = new ArrayList<SectorEntityToken>();
            for (SectorEntityToken curr : patrolPoints) {
                this.patrolPoints.add(curr);
            }
            this.randomizeLocation = randomizeLocation;
            this.system = system;
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.addScript(new TriggerFleetAssignmentAI(context.travelText, context.patrolText, 
                    context.mission, system, randomizeLocation, context.fleet, patrolPoints.toArray(new SectorEntityToken[0])));
        }
    }
    
    public static class OrderFleetPatrolSpawnedEntity implements TriggerAction {
        protected boolean moveToNearEntity;
 
        public OrderFleetPatrolSpawnedEntity(boolean moveToNearEntity) {
            this.moveToNearEntity = moveToNearEntity;
        }
        
        public void doAction(TriggerActionContext context) {
            SectorEntityToken entity = context.entity;
            if (entity == null) entity = context.jumpPoint;
            if (entity == null) entity = context.token;
            if (entity == null) entity = context.planet;
            context.fleet.addScript(
                    new TriggerFleetAssignmentAI(context.travelText, context.patrolText, context.mission,
                            context.entity.getContainingLocation(), moveToNearEntity, context.fleet, entity));
        }
    }
 
 
    public static class OrderFleetPatrolTagsAction implements TriggerAction {
        protected List<SectorEntityToken> added;
        protected StarSystemAPI system;
        protected boolean randomizeLocation;
        protected String[] tags;
 
        public OrderFleetPatrolTagsAction(StarSystemAPI system,
                boolean randomizeLocation, String ... tags) {
            this.system = system;
            this.randomizeLocation = randomizeLocation;
            this.tags = tags;
        }
 
        public void doAction(TriggerActionContext context) {
            List<SectorEntityToken> points = new ArrayList<SectorEntityToken>();
            for (SectorEntityToken entity : system.getAllEntities()) {
                for (String tag : tags) {
                    if (entity.hasTag(tag)) {
                        points.add(entity);
                        break;
                    }
                }
            }
            if (added != null) points.addAll(added);
            context.fleet.addScript(new TriggerFleetAssignmentAI(context.travelText, context.patrolText, context.mission, system, randomizeLocation, context.fleet,
                                    points.toArray(new SectorEntityToken[0])));
        }
    }
 
    public static class OrderFleetStopPursuingPlayerUnlessInStage implements TriggerAction {
        protected List<Object> stages;
        protected BaseHubMission mission;
        public OrderFleetStopPursuingPlayerUnlessInStage(BaseHubMission mission, Object...stages) {
            this.mission = mission;
            this.stages = Arrays.asList(stages);
        }
 
        public void doAction(TriggerActionContext context) {
            context.fleet.addScript(new MissionFleetStopPursuingPlayer(context.fleet, mission, stages));
        }
    }
    
    public static class OrderFleetInterceptNearbyPlayerInStage implements TriggerAction {
        protected List<Object> stages;
        protected BaseHubMission mission;
        protected float maxRange;
        protected boolean repeatable;
        protected boolean mustBeStrongEnoughToFight;
        protected float repeatDelay;
        public OrderFleetInterceptNearbyPlayerInStage(BaseHubMission mission, 
                boolean mustBeStrongEnoughToFight,
                float maxRange, 
                boolean repeatable, float repeatDelay, Object...stages) {
            this.mission = mission;
            this.mustBeStrongEnoughToFight = mustBeStrongEnoughToFight;
            this.maxRange = maxRange;
            this.repeatable = repeatable;
            this.repeatDelay = repeatDelay;
            this.stages = Arrays.asList(stages);
        }
        
        public void doAction(TriggerActionContext context) {
            context.fleet.addScript(new MissionFleetInterceptPlayerIfNearby(context.fleet, mission, 
                    mustBeStrongEnoughToFight, maxRange, repeatable, repeatDelay, stages));
        }
    }
    
 
    public static class OrderFleetInterceptPlayerAction implements TriggerAction {
        protected boolean makeHostile;
        public OrderFleetInterceptPlayerAction(boolean makeHostile) {
            this.makeHostile = makeHostile;
        }
 
        public void doAction(TriggerActionContext context) {
            TransmitterTrapSpecial.makeFleetInterceptPlayer(context.fleet, false, false, makeHostile, 1000f);
            if (!context.fleet.hasScriptOfClass(MissionFleetAutoDespawn.class)) {
                context.fleet.addScript(new MissionFleetAutoDespawn(context.mission, context.fleet));
            }
        }
    }
    
    public static class OrderFleetEBurn implements TriggerAction {
        public OrderFleetEBurn() {
        }
        
        public void doAction(TriggerActionContext context) {
            AbilityPlugin eb = context.fleet.getAbility(Abilities.EMERGENCY_BURN);
            if (eb != null && eb.isUsable()) eb.activate();
        }
    }
 
 
    public static class FleetNoAutoDespawnAction implements TriggerAction {
        public void doAction(TriggerActionContext context) {
            context.fleet.removeScriptsOfClass(MissionFleetAutoDespawn.class);
        }
    }
 
 
    public static class PickLocationAtInSystemJumpPointAction implements TriggerAction {
        protected StarSystemAPI system;
        protected float minDistFromPlayer;
 
        public PickLocationAtInSystemJumpPointAction(StarSystemAPI system,
                float minDistFromPlayer) {
            this.system = system;
            this.minDistFromPlayer = minDistFromPlayer;
        }
 
        public void doAction(TriggerActionContext context) {
            WeightedRandomPicker<SectorEntityToken> picker = new WeightedRandomPicker<SectorEntityToken>(((BaseHubMission)context.mission).genRandom);
            picker.addAll(system.getJumpPoints());
            
            SectorEntityToken pick = picker.pick();
            Vector2f loc = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, pick, 0, 360f, minDistFromPlayer, 0f, 0f);
            
            context.jumpPoint = pick;
            context.coordinates = loc;
            context.containingLocation = system;
        }
    }
    
    public static class PickLocationAtClosestToPlayerJumpPointAction implements TriggerAction {
        protected StarSystemAPI system;
        protected float minDistFromPlayer;
        
        public PickLocationAtClosestToPlayerJumpPointAction(StarSystemAPI system, float minDistFromPlayer) {
            this.system = system;
            this.minDistFromPlayer = minDistFromPlayer;
        }
        
        public void doAction(TriggerActionContext context) {
            WeightedRandomPicker<SectorEntityToken> picker = new WeightedRandomPicker<SectorEntityToken>(((BaseHubMission)context.mission).genRandom);
            
            SectorEntityToken closest = null;
            float minDist = Float.MAX_VALUE;
            for (SectorEntityToken jp : system.getJumpPoints()) {
                if (system.isCurrentLocation()) {
                    float dist = Misc.getDistance(jp, Global.getSector().getPlayerFleet());
                    if (dist < minDist) {
                        closest = jp;
                        minDist = dist;
                    }
                } else {
                    picker.add(jp);
                }
            }
            if (closest != null) {
                picker.add(closest);
            }
            
            SectorEntityToken pick = picker.pick();
            Vector2f loc = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, pick, 0, 360f, minDistFromPlayer, 0f, 0f);
            
            context.jumpPoint = pick;
            context.coordinates = loc;
            context.containingLocation = system;
        }
    }
    
    public static class PickLocationAtClosestToEntityJumpPointAction implements TriggerAction {
        protected StarSystemAPI system;
        protected float minDistFromEntity;
        protected SectorEntityToken entity;
        
        public PickLocationAtClosestToEntityJumpPointAction(StarSystemAPI system, SectorEntityToken entity, float minDistFromEntity) {
            this.system = system;
            this.entity = entity;
            this.minDistFromEntity = minDistFromEntity;
        }
        
        public void doAction(TriggerActionContext context) {
            WeightedRandomPicker<SectorEntityToken> picker = new WeightedRandomPicker<SectorEntityToken>(((BaseHubMission)context.mission).genRandom);
            
            SectorEntityToken closest = null;
            float minDist = Float.MAX_VALUE;
            for (SectorEntityToken jp : system.getJumpPoints()) {
                if (system.isCurrentLocation()) {
                    float dist = Misc.getDistance(jp, entity);
                    if (dist < minDist) {
                        closest = jp;
                        minDist = dist;
                    }
                } else {
                    picker.add(jp);
                }
            }
            if (closest != null) {
                picker.add(closest);
            }
            
            SectorEntityToken pick = picker.pick();
            Vector2f loc = pickLocationWithinArc(((BaseHubMission)context.mission).genRandom, pick, 0, 360f, minDistFromEntity, 0f, 0f);
            
            context.jumpPoint = pick;
            context.coordinates = loc;
            context.containingLocation = system;
        }
    }
    
    public static class CreateFleetAction implements TriggerAction {
        public long seed;
        
        public FleetParamsV3 params;
        public FleetSize fSize;
        public Float fSizeOverride;
        public Float combatFleetPointsOverride;
        public FleetQuality fQuality;
        public Float fQualityMod;
        public Integer fQualitySMods;
        public OfficerNum oNum;
        public OfficerQuality oQuality;
        public Boolean doNotIntegrateAICores;
        public String faction = null;
        
        public Float freighterMult = null;
        public Float tankerMult = null;
        public Float linerMult = null;
        public Float transportMult = null;
        public Float utilityMult = null;
        public Float qualityMod = null;
        public Float qualityOverride = null;
        
        public Float damage = null;
        
        public Boolean allWeapons;
        public ShipPickMode shipPickMode;
        public Boolean removeInflater;
        
        public String nameOverride = null;
        public Boolean noFactionInName = null;
 
        public CreateFleetAction(String type, Vector2f locInHyper,
                FleetSize fSize, FleetQuality fQuality, String factionId) {
            seed = Misc.genRandomSeed();
            params = new FleetParamsV3(locInHyper, factionId, null, type, 0f, 0f, 0f, 0f, 0f, 0f, 0f);
            params.ignoreMarketFleetSizeMult = true;
            
            this.fSize = fSize;
            this.fQuality = fQuality;
            
            freighterMult = 0.1f;
            tankerMult = 0.1f;
        }
 
        public void doAction(TriggerActionContext context) {
            //Random random = new Random(seed);
            Random random = null;
            if (context.mission != null) {
                random = ((BaseHubMission)context.mission).genRandom; 
            } else {
                random = Misc.random;
            }
            FactionAPI faction = Global.getSector().getFaction(params.factionId);
            float maxPoints = faction.getApproximateMaxFPPerFleet(ShipPickMode.PRIORITY_THEN_ALL);
            
            //strength = FleetStrength.MAXIMUM;
            
            //float fraction = fSize.maxFPFraction * (0.9f + random.nextFloat() * 0.2f);
            float min = fSize.maxFPFraction - (fSize.maxFPFraction - fSize.prev().maxFPFraction) / 2f; 
            float max = fSize.maxFPFraction + (fSize.next().maxFPFraction - fSize.maxFPFraction) / 2f;
            float fraction = min + (max - min) * random.nextFloat();
            
            float excess = 0;
            
            if (fSizeOverride != null) {
                fraction = fSizeOverride * (0.95f + random.nextFloat() * 0.1f);
            }
            else {
                int numShipsDoctrine = 1;
                if (params.doctrineOverride != null) numShipsDoctrine = params.doctrineOverride.getNumShips();
                else if (faction != null) numShipsDoctrine = faction.getDoctrine().getNumShips();
                float doctrineMult = FleetFactoryV3.getDoctrineNumShipsMult(numShipsDoctrine);
                fraction *= 0.75f * doctrineMult;
                if (fraction > FleetSize.MAXIMUM.maxFPFraction) {
                    excess = fraction - FleetSize.MAXIMUM.maxFPFraction;
                    fraction = FleetSize.MAXIMUM.maxFPFraction;
                }
            }
            
            //fraction = 1f;
            
            float combatPoints = fraction * maxPoints;
            if (combatFleetPointsOverride != null) {
                combatPoints = combatFleetPointsOverride;
            }
 
            FactionDoctrineAPI doctrine = params.doctrineOverride;
            if (excess > 0) {
                if (doctrine == null) {
                    doctrine = faction.getDoctrine().clone();
                }
                int added = (int)Math.round(excess / 0.1f);
                if (added > 0) {
                    doctrine.setOfficerQuality(Math.min(5, doctrine.getOfficerQuality() + added));
                    doctrine.setShipQuality(doctrine.getShipQuality() + added);
                }
            }
//          if (fraction > 0.5f && false) {
//              if (doctrine == null) {
//                  doctrine = faction.getDoctrine().clone();
//              }
//              int added = (int)Math.round((fraction - 0.5f) / 0.1f);
//              if (added > 0) {
//                  doctrine.setNumShips(Math.max(1, doctrine.getNumShips() - added));
//                  doctrine.setOfficerQuality(Math.min(5, doctrine.getOfficerQuality() + added));
//                  doctrine.setShipQuality(doctrine.getShipQuality() + added);
//              }
//          }
            
            if (freighterMult == null) freighterMult = 0f;
            if (tankerMult == null) tankerMult = 0f;
            if (linerMult == null) linerMult = 0f;
            if (transportMult == null) transportMult = 0f;
            if (utilityMult == null) utilityMult = 0f;
            if (qualityMod == null) qualityMod = 0f;
            
            params.combatPts = combatPoints;
            params.freighterPts = combatPoints * freighterMult; 
            params.tankerPts = combatPoints * tankerMult;
            params.transportPts = combatPoints * transportMult;
            params.linerPts = combatPoints * linerMult;
            params.utilityPts = combatPoints * utilityMult;
            params.qualityMod = qualityMod;
            
//          if (damage != null && damage > 0) {
//              if (damage > 1) damage = 1f;
//              float mult1 = 1f - damage;
//              float mult2 = 1f - damage * 0.5f;
//              params.combatPts *= mult1;
//              params.freighterPts *= mult2;
//              params.tankerPts *= mult2;
//              params.transportPts *= mult2;
//              params.linerPts *= mult2;
//              params.utilityPts *= mult2;
//          }
            
            //params.modeOverride = ShipPickMode.PRIORITY_THEN_ALL; 
            params.doctrineOverride = doctrine;
            params.random = random;
            
 
            if (fQuality != null) {
                switch (fQuality) {
                case VERY_LOW:
                    if (fQualityMod != null) {
                        params.qualityMod += fQuality.qualityMod;
                    } else {
                        params.qualityOverride = 0f;
                    }
                    break;
                case LOWER:
                    params.qualityMod += fQuality.qualityMod;
                    break;
                case DEFAULT:
                    params.qualityMod += fQuality.qualityMod;
                    break;
                case HIGHER:
                    params.qualityMod += fQuality.qualityMod;
                    break;
                case VERY_HIGH:
                    if (fQualityMod != null) {
                        params.qualityMod += fQuality.qualityMod;
                    } else {
                        params.qualityMod += fQuality.qualityMod;
                        //params.qualityOverride = 1f;
                    }
                    break;
                case SMOD_1:
                    params.qualityMod += fQuality.qualityMod;
                    params.averageSMods = fQuality.numSMods;
                    break;
                case SMOD_2:
                    params.qualityMod += fQuality.qualityMod;
                    params.averageSMods = fQuality.numSMods;
                    break;
                case SMOD_3:
                    params.qualityMod += fQuality.qualityMod;
                    params.averageSMods = fQuality.numSMods;
                    break;
                }
            }
            if (fQualityMod != null) {
                params.qualityMod += fQualityMod;
            }
            if (fQualitySMods != null) {
                params.averageSMods = fQualitySMods;
            }
            
            if (oNum != null) {
                switch (oNum) {
                case NONE:
                    params.withOfficers = false;
                    break;
                case FC_ONLY:
                    params.officerNumberMult = 0f;
                    break;
                case FEWER:
                    params.officerNumberMult = 0.5f;
                    break;
                case DEFAULT:
                    break;
                case MORE:
                    params.officerNumberMult = 1.5f;
                    break;
                case ALL_SHIPS:
                    params.officerNumberBonus = Global.getSettings().getInt("maxShipsInAIFleet");
                    break;
                }
            }
            
            if (oQuality != null) {
                switch (oQuality) {
                case LOWER:
                    params.officerLevelBonus = -3;
                    params.officerLevelLimit = Global.getSettings().getInt("officerMaxLevel") - 1;
                    params.commanderLevelLimit = Global.getSettings().getInt("maxAIFleetCommanderLevel") - 2;
                    if (params.commanderLevelLimit < params.officerLevelLimit) {
                        params.commanderLevelLimit = params.officerLevelLimit;
                    }
                    break;
                case DEFAULT:
                    break;
                case HIGHER:
                    params.officerLevelBonus = 2;
                    params.officerLevelLimit = Global.getSettings().getInt("officerMaxLevel") + (int) OfficerTraining.MAX_LEVEL_BONUS;
                    break;
                case UNUSUALLY_HIGH:
                    params.officerLevelBonus = 4;
                    params.officerLevelLimit = SalvageSpecialAssigner.EXCEPTIONAL_PODS_OFFICER_LEVEL;
                    break;
                case AI_GAMMA:
                case AI_BETA:
                case AI_BETA_OR_GAMMA:
                case AI_ALPHA:
                case AI_MIXED:
                case AI_OMEGA:
                    params.aiCores = oQuality;
                    break;
                }
                if (doNotIntegrateAICores != null) {
                    params.doNotIntegrateAICores = doNotIntegrateAICores;
                }
            }
            
            if (shipPickMode != null) {
                params.modeOverride = shipPickMode;
            }
            
            params.updateQualityAndProducerFromSourceMarket();
            if (qualityOverride != null) {
                params.qualityOverride = qualityOverride + params.qualityMod;;
            }
            context.fleet = FleetFactoryV3.createFleet(params);
            context.fleet.setFacing(random.nextFloat() * 360f);
            
            if (this.faction != null) {
                context.fleet.setFaction(this.faction, true);
            }
            
            if (this.nameOverride != null) {
                context.fleet.setName(this.nameOverride);
            }
            if (this.noFactionInName != null && this.noFactionInName) {
                context.fleet.setNoFactionInName(noFactionInName);
            }
            
            if (removeInflater != null && removeInflater) {
                context.fleet.setInflater(null);
            } else {
                if (context.fleet.getInflater() instanceof DefaultFleetInflater) {
                    DefaultFleetInflater inflater = (DefaultFleetInflater) context.fleet.getInflater();
                    if (inflater.getParams() instanceof DefaultFleetInflaterParams) {
                        DefaultFleetInflaterParams p = (DefaultFleetInflaterParams) inflater.getParams();
                        if (allWeapons != null) {
                            p.allWeapons = allWeapons;
                        }
                        if (shipPickMode != null) {
                            p.mode = shipPickMode;
                        }
                    }
                }
            }
            
            context.fleet.getMemoryWithoutUpdate().set(MemFlags.FLEET_BUSY, true);
            //context.fleet.getMemoryWithoutUpdate().set("$LP_titheAskedFor", true);
            
            context.allFleets.add(context.fleet);
            
            if (!context.fleet.hasScriptOfClass(MissionFleetAutoDespawn.class)) {
                context.fleet.addScript(new MissionFleetAutoDespawn(context.mission, context.fleet));
            }
            
            if (damage != null) {
                FleetFactoryV3.applyDamageToFleet(context.fleet, damage, false, random);
            }
            
//          if (Factions.PIRATES.equals(params.factionId)) {
//              
//          }
        }
    }
    
    
//  public TriggerAction getPreviousAction() {
//      if (currTrigger.getActions().isEmpty()) return null;
//      return currTrigger.getActions().get(currTrigger.getActions().size() - 1);
//  }
    public CreateFleetAction getPreviousCreateFleetAction() {
        for (int i = currTrigger.getActions().size() - 1; i >= 0; i--) {
            TriggerAction action = currTrigger.getActions().get(i);
            if (action instanceof CreateFleetAction) {
                return (CreateFleetAction) action;
            }
        }
        return null;
    }
 
    public void triggerMovePersonToMarket(PersonAPI person, MarketAPI market, boolean alwaysAddToComms) {
        triggerCustomAction(new MovePersonToMarket(person, market, alwaysAddToComms));
    }
    public void triggerIncreaseMarketHostileTimeout(MarketAPI market, float days) {
        triggerCustomAction(new IncreaseMarketHostileTimeout(market, days));
    }
    public void triggerRunScriptAfterDelay(float delay, Script script) {
        triggerCustomAction(new RunScriptAfterDelay(delay, script));
    }
    public void triggerAddTagAfterDelay(float delay, StarSystemAPI system, String tag) {
        triggerCustomAction(new AddTagAfterDelay(delay, system, tag));
    }
    public void triggerSetMemoryValueAfterDelay(float delay, HasMemory hasMemory, String key, Object value) {
        triggerSetMemoryValueAfterDelay(delay, hasMemory.getMemory(), key, value);
    }
    public void triggerSetMemoryValueAfterDelay(float delay, MemoryAPI memory, String key, Object value) {
        triggerCustomAction(new SetMemoryValueAfterDelay(delay, memory, key, value));
    }
    public void triggerSetGlobalMemoryValueAfterDelay(float delay, String key, Object value) {
        triggerCustomAction(new SetMemoryValueAfterDelay(delay, Global.getSector().getMemory(), key, value));
    }
    public float genDelay(float base) {
        return base * StarSystemGenerator.getNormalRandom(genRandom, 0.75f, 1.25f);
    }
    
    public void triggerUnhideCommListing(PersonAPI person) {
        triggerCustomAction(new UnhideCommListing(person));
    }
    public void triggerHideCommListing(PersonAPI person) {
        triggerCustomAction(new HideCommListing(person));
    }
    public void triggerSaveGlobalEntityRef(String key) {
        triggerSaveEntityRef(Global.getSector().getMemoryWithoutUpdate(), key);
    }
    public void triggerSaveEntityRef(MemoryAPI memory, String key) {
        triggerCustomAction(new SaveEntityReferenceAction(memory, key));
    }
    public void triggerSaveGlobalFleetRef(String key) {
        triggerSaveFleetRef(Global.getSector().getMemoryWithoutUpdate(), key);
    }
    public void triggerSaveFleetRef(MemoryAPI memory, String key) {
        triggerCustomAction(new SaveFleetReferenceAction(memory, key));
    }
    
    public SectorEntityToken getEntityFromGlobal(String key) {
        return Global.getSector().getMemoryWithoutUpdate().getEntity(key);
    }
    
    public void triggerCreateFleet(FleetSize size, FleetQuality quality, String factionId, String type, StarSystemAPI roughlyWhere) {
        triggerCustomAction(new CreateFleetAction(type, roughlyWhere.getLocation(), size, quality, factionId));
    }
    public void triggerCreateFleet(FleetSize size, FleetQuality quality, String factionId, String type, SectorEntityToken roughlyWhere) {
        triggerCustomAction(new CreateFleetAction(type, roughlyWhere.getLocationInHyperspace(), size, quality, factionId));
    }
    public void triggerCreateFleet(FleetSize size, FleetQuality quality, String factionId, String type, Vector2f locInHyper) {
        triggerCustomAction(new CreateFleetAction(type, locInHyper, size, quality, factionId));
    }
    
    public void triggerAutoAdjustFleetSize(FleetSize min, FleetSize max) {
        float f = getQualityFraction();
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.fSizeOverride = min.maxFPFraction + (max.maxFPFraction - min.maxFPFraction) * f;
        
        autoAdjustFleetTypeName();
    }
    
    public void triggerSetFleetSizeFraction(float fractionOfMax) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.fSizeOverride = fractionOfMax;
    }
    public void triggerSetFleetCombatFleetPoints(float combatFleetPointsOverride) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.combatFleetPointsOverride = combatFleetPointsOverride;
    }
    public void triggerAutoAdjustFleetQuality(FleetQuality min, FleetQuality max) {
        float f = getQualityFraction();
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.fQualityMod = min.qualityMod + (max.qualityMod - min.qualityMod) * f;
        cfa.fQualitySMods = (int) Math.round(min.numSMods + (max.numSMods - min.numSMods) * f);
        if (cfa.fQualitySMods <= 0) {
            cfa.fQualitySMods = null;
        }
    }
    
    public void triggerAutoAdjustOfficerNum(OfficerNum min, OfficerNum max) {
        float f = getQualityFraction();
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.oNum = (OfficerNum) pickEnum(f, getEnums(min, max));
    }
    public void triggerAutoAdjustOfficerQuality(OfficerQuality min, OfficerQuality max) {
        float f = getQualityFraction();
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.oQuality = (OfficerQuality) pickEnum(f, getEnums(min, max));
    }
    
    public void triggerSetFleetQuality(FleetQuality quality) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa != null) {
            cfa.fQuality = quality;
        }
    }
    public void triggerSetFleetSize(FleetSize size) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa != null) {
            cfa.fSize= size;
        }
    }
    
    public void triggerRandomizeFleetStrengthMinor() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        FleetSize size = cfa.fSize;
        if (size == null) size = FleetSize.MEDIUM;
        
        float min = size.maxFPFraction - (size.maxFPFraction - size.prev().maxFPFraction) / 2f; 
        float max = size.maxFPFraction + (size.next().maxFPFraction - size.maxFPFraction) / 2f;
        cfa.fSizeOverride = min + (max - min) * genRandom.nextFloat();
        //triggerAutoAdjustFleetSize(size.prev(), size.next());
        
        FleetQuality fq = cfa.fQuality;
        if (fq == null) fq = FleetQuality.DEFAULT;
        min = fq.qualityMod - (fq.qualityMod - fq.prev().qualityMod) / 2f; 
        max = fq.qualityMod + (fq.next().qualityMod - fq.qualityMod) / 2f;
        cfa.fQualityMod = min + (max - min) * genRandom.nextFloat();
        //triggerAutoAdjustFleetQuality(fq.prev(), fq.next());
    }
    
    public void triggerAutoAdjustFleetStrengthModerate() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        FleetSize size = cfa.fSize;
        if (size == null) size = FleetSize.MEDIUM;
        
        triggerAutoAdjustFleetSize(size.prev(), size.next());
        
        FleetQuality fq = cfa.fQuality;
        if (fq == null) fq = FleetQuality.DEFAULT;
        FleetQuality limit = FleetQuality.VERY_HIGH;
        FleetQuality next = fq;
        int steps = 1;
        while (next.next().ordinal() <= limit.ordinal() && steps > 0) {
            next = next.next();
            steps--;
        }
        limit = FleetQuality.LOWER;
        FleetQuality prev = fq;
        steps = 1;
        while (prev.prev().ordinal() >= limit.ordinal() && steps > 0) {
            prev = prev.prev();
            steps--;
        }
        triggerAutoAdjustFleetQuality(prev, next);
        
        
        OfficerNum oNum = cfa.oNum;
        if (oNum == null) oNum = OfficerNum.DEFAULT;
        if (oNum == OfficerNum.FEWER || oNum == OfficerNum.DEFAULT) {
            switch (oNum) {
            case FEWER:
                triggerAutoAdjustOfficerNum(OfficerNum.FEWER, OfficerNum.DEFAULT);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerNum(OfficerNum.DEFAULT, OfficerNum.MORE);
                break;
            }
        }
        
        OfficerQuality oQuality = cfa.oQuality;
        if (oQuality == null) oQuality = OfficerQuality.DEFAULT;
        if (oQuality == OfficerQuality.LOWER || oQuality == OfficerQuality.DEFAULT) {
            switch (oQuality) {
            case LOWER:
                triggerAutoAdjustOfficerQuality(OfficerQuality.LOWER, OfficerQuality.DEFAULT);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerQuality(OfficerQuality.DEFAULT, OfficerQuality.HIGHER);
                break;
            }
        }
    }
    
    public void triggerAutoAdjustFleetStrengthMajor() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        FleetSize size = cfa.fSize;
        if (size == null) size = FleetSize.MEDIUM;
        
        triggerAutoAdjustFleetSize(size.prev().prev(), size.next().next());
        
        FleetQuality fq = cfa.fQuality;
        if (fq == null) fq = FleetQuality.DEFAULT;
        FleetQuality limit = FleetQuality.VERY_HIGH;
        FleetQuality next = fq;
        int steps = 2;
        while (next.next().ordinal() <= limit.ordinal() && steps > 0) {
            next = next.next();
            steps--;
        }
        limit = FleetQuality.LOWER;
        FleetQuality prev = fq;
        steps = 2;
        while (prev.prev().ordinal() >= limit.ordinal() && steps > 0) {
            prev = prev.prev();
            steps--;
        }
        triggerAutoAdjustFleetQuality(prev, next);
        
        
        OfficerNum oNum = cfa.oNum;
        if (oNum == null) oNum = OfficerNum.DEFAULT;
        if (oNum == OfficerNum.FEWER || oNum == OfficerNum.DEFAULT) {
            switch (oNum) {
            case FEWER:
                triggerAutoAdjustOfficerNum(OfficerNum.FEWER, OfficerNum.DEFAULT);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerNum(OfficerNum.DEFAULT, OfficerNum.MORE);
                break;
            }
        }
        
        OfficerQuality oQuality = cfa.oQuality;
        if (oQuality == null) oQuality = OfficerQuality.DEFAULT;
        if (oQuality == OfficerQuality.LOWER || oQuality == OfficerQuality.DEFAULT) {
            switch (oQuality) {
            case LOWER:
                triggerAutoAdjustOfficerQuality(OfficerQuality.LOWER, OfficerQuality.DEFAULT);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerQuality(OfficerQuality.DEFAULT, OfficerQuality.HIGHER);
                break;
            }
        }
    }
    
    public void triggerAutoAdjustFleetStrengthExtreme() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        FleetSize size = cfa.fSize;
        if (size == null) size = FleetSize.MEDIUM;
        
        triggerAutoAdjustFleetSize(size.prev().prev(), size.next().next().next());
        
        FleetQuality fq = cfa.fQuality;
        if (fq == null) fq = FleetQuality.DEFAULT;
        FleetQuality limit = FleetQuality.SMOD_1;
        FleetQuality next = fq;
        int steps = 3;
        while (next.next().ordinal() <= limit.ordinal() && steps > 0) {
            next = next.next();
            steps--;
        }
        limit = FleetQuality.LOWER;
        FleetQuality prev = fq;
        steps = 2;
        while (prev.prev().ordinal() >= limit.ordinal() && steps > 0) {
            prev = prev.prev();
            steps--;
        }
        triggerAutoAdjustFleetQuality(prev, next);
        
        
        OfficerNum oNum = cfa.oNum;
        if (oNum == null) oNum = OfficerNum.DEFAULT;
        if (oNum == OfficerNum.FEWER || oNum == OfficerNum.DEFAULT || oNum == OfficerNum.MORE) {
            switch (oNum) {
            case FEWER:
                triggerAutoAdjustOfficerNum(OfficerNum.FEWER, OfficerNum.MORE);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerNum(OfficerNum.FEWER, OfficerNum.ALL_SHIPS);
                break;
            case MORE:
                triggerAutoAdjustOfficerNum(OfficerNum.DEFAULT, OfficerNum.ALL_SHIPS);
                break;
            }
        }
        
        OfficerQuality oQuality = cfa.oQuality;
        if (oQuality == null) oQuality = OfficerQuality.DEFAULT;
        if (oQuality == OfficerQuality.LOWER || oQuality == OfficerQuality.DEFAULT) {
            switch (oQuality) {
            case LOWER:
                triggerAutoAdjustOfficerQuality(OfficerQuality.LOWER, OfficerQuality.DEFAULT);
                break;
            case DEFAULT:
                triggerAutoAdjustOfficerQuality(OfficerQuality.DEFAULT, OfficerQuality.HIGHER);
                break;
            }
        }
    }
    
    
    protected transient boolean useQualityInsteadOfQualityFraction = false;
    public void setUseQualityInsteadOfQualityFraction(boolean temporarilyUseQualityInsteadOfQualityFraction) {
        this.useQualityInsteadOfQualityFraction = temporarilyUseQualityInsteadOfQualityFraction;
    }
 
    protected float getQualityFraction() {
        float quality = getQuality();
        if (useQualityInsteadOfQualityFraction) {
            return quality;
        }
        
        float minQuality = getMinQuality();
        float maxQuality = getMaxQuality();
        float base = getBaseQuality();
        
        float f;
        if (quality < base) {
            float range = base - minQuality;
            f = 0f;
            if (range > 0) {
                f = (quality - minQuality) / range;
            }
            if (f < 0) f = 0;
            if (f > 1) f = 1;
            f = f * 0.5f;
        } else {
            float range = maxQuality - base;
            f = 1f;
            if (range > 0) {
                f = (quality - base) / range;
            }
            if (f < 0) f = 0;
            if (f > 1) f = 1;
            f = 0.5f + f * 0.5f;
        }
        return f;
    }
    
    @SuppressWarnings("unchecked")
    protected Object [] getEnums(Enum from, Enum to) {
        return EnumSet.range(from, to).toArray();
    }
    
    protected Object pickEnum(float f, Object ... enums) {
        float num = enums.length;
        f *= (num - 1f);
        
        float rem = (float)(f - (int) f);
        if (rem < 0.2f) rem = 0f;
        if (rem > 0.8f) rem = 1f;
        
        int index = (int) f;
        if (genRandom.nextFloat() < rem) {
            index++;
        } 
        if (index > enums.length - 1) index = enums.length - 1;
        if (index < 0) index = 0;
        return enums[index];
    }
 
//  defaults to this
//  public void triggerSetFleetCompositionStandardSupportShips() {
//      triggerSetFleetComposition(0.1f, 0.1f, 0f, 0f, 0f, 0f);
//  }
    
    public void triggerSetFleetCompositionNoSupportShips() {
        triggerSetFleetComposition(0f, 0f, 0f, 0f, 0f);
    }
            
    public void triggerSetFleetComposition(float freighterMult, float tankerMult,
                                           float transportMult, float linerMult,
                                           float utilityMult) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (freighterMult > 0) cfa.freighterMult = freighterMult;
        else cfa.freighterMult = null;
        
        if (tankerMult > 0) cfa.tankerMult = tankerMult;
        else cfa.tankerMult = null;
        
        if (transportMult > 0) cfa.transportMult = transportMult;
        else cfa.transportMult = null;
        
        if (linerMult > 0) cfa.linerMult = linerMult;
        else cfa.linerMult = null;
        
        if (utilityMult > 0) cfa.utilityMult = utilityMult;
        else cfa.utilityMult = null;
    }
    
    public void triggerSetFleetDoctrineComp(int warships, int carriers, int phaseShips) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        
        if (cfa.params.doctrineOverride == null) {
            FactionAPI faction = Global.getSector().getFaction(cfa.params.factionId);
            cfa.params.doctrineOverride = faction.getDoctrine().clone();
        }
        
        cfa.params.doctrineOverride.setWarships(warships);
        cfa.params.doctrineOverride.setCarriers(carriers);
        cfa.params.doctrineOverride.setPhaseShips(phaseShips);
    }
    
    public void triggerAddShips(String ...variants) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa.params.addShips == null) {
            cfa.params.addShips = new ArrayList<String>();
        }
        for (String id : variants) {
            cfa.params.addShips.add(id);
        }
    }
    
    public void triggerSetFleetProbabilityCombatFreighters(float prob) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa.params.doctrineOverride == null) {
            FactionAPI faction = Global.getSector().getFaction(cfa.params.factionId);
            cfa.params.doctrineOverride = faction.getDoctrine().clone();
        }
        
        cfa.params.doctrineOverride.setCombatFreighterProbability(prob);
    }
    
    public void triggerSetFleetDoctrineQuality(int officerQuality, int shipQuality, int numShips) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        
        if (cfa.params.doctrineOverride == null) {
            FactionAPI faction = Global.getSector().getFaction(cfa.params.factionId);
            cfa.params.doctrineOverride = faction.getDoctrine().clone();
        }
        
        if (officerQuality >= 0) {
            cfa.params.doctrineOverride.setOfficerQuality(officerQuality);
        }
        
        if (shipQuality >= 0) {
            cfa.params.doctrineOverride.setShipQuality(shipQuality);
        }
        
        if (numShips >= 0) {
            cfa.params.doctrineOverride.setNumShips(numShips);
        }
    }
    
    public void triggerSetFleetDoctrineOther(int shipSize, int aggression) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        
        if (cfa.params.doctrineOverride == null) {
            FactionAPI faction = Global.getSector().getFaction(cfa.params.factionId);
            cfa.params.doctrineOverride = faction.getDoctrine().clone();
        }
        
        if (shipSize >= 0) {
            cfa.params.doctrineOverride.setShipSize(shipSize);
        }
        if (aggression >= 0) {
            cfa.params.doctrineOverride.setAggression(aggression);
        }
    }
    
    public void triggerSetFleetDoctrineRandomize(float randomizeProb) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        
        if (cfa.params.doctrineOverride == null) {
            FactionAPI faction = Global.getSector().getFaction(cfa.params.factionId);
            cfa.params.doctrineOverride = faction.getDoctrine().clone();
        }
        
        cfa.params.doctrineOverride.setAutofitRandomizeProbability(randomizeProb);
    }
    
    public void triggerSetFleetSizeAndQuality(FleetSize size, FleetQuality quality, String fleetType) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.fSize = size;
        cfa.fQuality = quality;
        cfa.params.fleetType = fleetType;
        cfa.fSizeOverride = null;
    }
    public void triggerSetFleetType(String fleetType) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.fleetType = fleetType;
    }
    
    public void triggerSetFleetOfficers(OfficerNum num, OfficerQuality quality) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.oNum = num;
        cfa.oQuality = quality;
    }
    
    public void triggerFleetSetCommander(PersonAPI commander) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.commander = commander;
    }
    
    public void triggerSetFleetNoCommanderSkills() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.noCommanderSkills = true;
    }
    
    public void triggerSetFleetMaxShipSize(int max) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.maxShipSize = max;
    }
    public void triggerSetFleetMinShipSize(int min) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.minShipSize = min;
    }
    public void triggerSetFleetMaxNumShips(int num) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.maxNumShips = num;
    }
    
    public void triggerFleetSetSingleShipOnly() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.onlyRetainFlagship = true;
    }
    public void triggerFleetSetFlagship(String variantId) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.flagshipVariantId = variantId;
    }
    
    public void triggerFleetSetFlagship(ShipVariantAPI variant) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.params.flagshipVariant = variant;
    }
    
    public void triggerFleetRemoveInflater() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.removeInflater = true;
    }
    
    public void triggerFleetSetShipPickMode(ShipPickMode mode) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.shipPickMode = mode;
    }
    
    public void triggerFleetSetAllWeapons() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.allWeapons = true;
    }
    
//  public void triggerFleetSetFaction(String factionId) {
//      CreateFleetAction cfa = getPreviousCreateFleetAction();
//      cfa.faction = factionId;
//  }
    public void triggerSetFleetFaction(final String factionId) {
//      triggerCustomAction(new SetFleetFactionAction(factionId));
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.faction = factionId;
    }
    
    public void triggerFleetSetName(String name) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.nameOverride = name;
    }
    public void triggerFleetSetNoFactionInName() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.noFactionInName = true;
    }
    public void triggerFleetDoNotIntegrateAICores() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        cfa.doNotIntegrateAICores = true;
    }
    
    public FleetParamsV3 triggerGetFleetParams() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        return cfa.params;
    }
    
    
    public void triggerSetFleetCommander(final PersonAPI commander) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa != null && cfa.params != null) {
            cfa.params.commander = commander;
        } else {
            triggerCustomAction(new TriggerAction() {
                public void doAction(TriggerActionContext context) {
                    context.fleet.setCommander(commander);
                    context.fleet.getFleetData().ensureHasFlagship();
                }
            });
        }
    }
// commander will get overriden by default inflater so uh
// will it? doesn't seem like it would, looking at DFI
//  public void triggerSetFleetCommanderFlags(final String ... flags) {
//      triggerCustomAction(new TriggerAction() {
//          public void doAction(TriggerActionContext context) {
//              for (String flag : flags) {
//                  context.fleet.getCommander().getMemoryWithoutUpdate().set(flag, true);
//              }
//          }
//      });
//  }
    
    public void triggerFleetMakeImportantPermanent(String flag) {
        triggerCustomAction(new FleetMakeImportantAction(flag, (Enum[]) null));
    }
    public void triggerFleetMakeImportant(String flag, Enum ... stages) {
        triggerCustomAction(new FleetMakeImportantAction(flag, stages));
    }
    public void triggerEntityMakeImportant(String flag, Enum ... stages) {
        triggerCustomAction(new EntityMakeImportantAction(flag, stages));
    }
    
    public void triggerSetFleetFlagsWithReasonPermanent(final String ... flags) {
        triggerCustomAction(new SetFleetFlagsWithReasonAction(getReason(), true, flags));
    }
    public void triggerSetFleetFlagsWithReason(final String ... flags) {
        triggerCustomAction(new SetFleetFlagsWithReasonAction(getReason(), false, flags));
    }
    
//  public void setFleetFlagsWithReason(final String ... flags) {
//      new SetFleetFlagsWithReasonAction(getReason(), false, flags).doAction(null);
//  }
//  
//  public void setFleetFlag(String flag) {
//      new SetFleetFlagAction(flag, false, (Object[])null).doAction(null);;
//  }
    
    public void triggerUnsetFleetFlagsWithReason(final String ... flags) {
        triggerCustomAction(new UnsetFleetFlagsWithReasonAction(getReason(), flags));
    }
    public void triggerSetPersonMissionRef(final String key) {
        triggerCustomAction(new SetPersonMissionRefAction(key));
    }
    public void triggerSetFleetMissionRef(final String key) {
        triggerCustomAction(new SetFleetMissionRefAction(key));
    }
    
    public void triggerSetFleetMemoryValue(final String key, final Object value) {
        triggerCustomAction(new SetFleetMemoryValueAction(key, value));
    }
    
    public void triggerSetMemoryValue(HasMemory withMemory, String key, Object value) {
        triggerCustomAction(new SetMemoryValueAction(withMemory.getMemoryWithoutUpdate(), key, value, true));
    }
    public void triggerSetMemoryValuePermanent(HasMemory withMemory, String key, Object value) {
        triggerCustomAction(new SetMemoryValueAction(withMemory.getMemoryWithoutUpdate(), key, value, false));
    }
    
    public void triggerSetGlobalMemoryValue(final String key, final Object value) {
        triggerCustomAction(new SetMemoryValueAction(Global.getSector().getMemoryWithoutUpdate(), key, value, true));
    }
    public void triggerSetGlobalMemoryValuePermanent(final String key, final Object value) {
        triggerCustomAction(new SetMemoryValueAction(Global.getSector().getMemoryWithoutUpdate(), key, value, false));
    }
    
    public void triggerSetFleetFlagPermanent(String flag) {
        triggerCustomAction(new SetFleetFlagAction(flag, true, (Object[])null));
    }
    public void triggerSetFleetGenericHailPermanent(String commsTrigger) {
        triggerSetFleetGenericHail(commsTrigger, (Object[])null);
    }
    public void triggerSetFleetGenericHail(String commsTrigger, Object ...stages) {
        if (stages == null || stages.length <= 0) {
            triggerSetFleetFlagPermanent("$genericHail");
        } else {
            triggerSetFleetFlag("$genericHail", stages);
        }
        triggerSetFleetMemoryValue("$genericHail_openComms", commsTrigger);
    }
    public void triggerSetFleetGenericHailIfNonHostilePermanent(String commsTrigger) {
        triggerSetFleetGenericHail(commsTrigger, (Object[])null);
    }
    public void triggerSetFleetGenericHailIfNonHostile(String commsTrigger, Object ...stages) {
        if (stages == null || stages.length <= 0) {
            triggerSetFleetFlagPermanent("$genericHail_nonHostile");
        } else {
            triggerSetFleetFlag("$genericHail_nonHostile", stages);
        }
        triggerSetFleetMemoryValue("$genericHail_openComms", commsTrigger);
    }
    public void triggerSetFleetFlag(String flag) {
        triggerCustomAction(new SetFleetFlagAction(flag, false, (Object[])null));
    }
    public void triggerSetEntityFlagPermanent(String flag) {
        triggerCustomAction(new SetEntityFlagAction(flag, true, (Object[])null));
    }
    public void triggerSetEntityFlag(String flag) {
        triggerCustomAction(new SetEntityFlagAction(flag, false, (Object[])null));
    }
    public void triggerSetFleetFlagPermanent(String flag, Object ... stages) {
        triggerCustomAction(new SetFleetFlagAction(flag, true, stages));
    }
    public void triggerSetFleetFlag(String flag, Object ... stages) {
        triggerCustomAction(new SetFleetFlagAction(flag, false, stages));
    }
    public void triggerUnsetFleetFlag(String flag) {
        triggerCustomAction(new UnsetFleetFlagsAction(flag));
    }
    public void triggerSetEntityFlagPermanent(String flag, Object ... stages) {
        triggerCustomAction(new SetEntityFlagAction(flag, true, stages));
    }
    public void triggerSetEntityFlag(String flag, Object ... stages) {
        triggerCustomAction(new SetEntityFlagAction(flag, false, stages));
    }
    public void triggerUnsetEntityFlag(String flag) {
        triggerCustomAction(new UnsetEntityFlagsAction(flag));
    }
//  public void triggerMakeHostileAndAggressiveNotPermanent(Object ... stages) {
//      triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE, 
//                                     MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE);
//      triggerSetFleetFlag(MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE_ONE_BATTLE_ONLY);
//  }
    public void triggerMakeHostileAndAggressive() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE, 
                             //MemFlags.MEMORY_KEY_MAKE_HOSTILE_WHILE_TOFF,
                             MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE);
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE_ONE_BATTLE_ONLY);
    }
    
    public void triggerMakeFleetIgnoreOtherFleetsExceptPlayer() {
        triggerMakeFleetIgnoreOtherFleets();
        triggerMakeFleetNotIgnorePlayer();
    }
    public void triggerMakeFleetNotIgnorePlayer() {
        triggerSetFleetFlag(MemFlags.FLEET_DO_NOT_IGNORE_PLAYER);
    }
    public void triggerMakeFleetIgnoreOtherFleets() {
        triggerSetFleetFlag(MemFlags.FLEET_IGNORES_OTHER_FLEETS);
    }
    public void triggerMakeFleetIgnoredByOtherFleets() {
        triggerSetFleetFlag(MemFlags.FLEET_IGNORED_BY_OTHER_FLEETS);
    }
    public void triggerMakeFleetAllowDisengage() {
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_MAKE_ALLOW_DISENGAGE);
    }
    
    public void makeHostileAndAggressive(CampaignFleetAPI fleet, boolean permanent) {
        setFlagWithReason(fleet, MemFlags.MEMORY_KEY_MAKE_HOSTILE, permanent);
        setFlagWithReason(fleet, MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE, permanent);
        setFlag(fleet, MemFlags.MEMORY_KEY_MAKE_AGGRESSIVE_ONE_BATTLE_ONLY, permanent);
    }
    
    public void triggerMakeNonHostile() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_NON_HOSTILE);
    }
    public void triggerMakeHostile() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE);
    }
    public void triggerMakeHostileToPlayerTradeFleets() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE_TO_PLAYER_TRADE_FLEETS);
    }
    public void triggerMakeHostileToAllTradeFleets() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE_TO_ALL_TRADE_FLEETS);
    }
    public void triggerMakeHostileWhileTransponderOff() {
//      triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE,
//                           MemFlags.MEMORY_KEY_MAKE_HOSTILE_WHILE_TOFF);
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_MAKE_HOSTILE_WHILE_TOFF);
    }
    public void triggerMakeLowRepImpact() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_LOW_REP_IMPACT);
    }
    public void triggerMakeEveryoneJoinBattleAgainst() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_EVERYONE_JOINS_BATTLE_AGAINST);
    }
//  public void triggerMakeNoOneJoinBattleToHelp() {
//      triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_NO_ONE_JOINTS_BATTLE_TO_HELP);
//  }
    public void triggerMakeAlwaysSpreadTOffHostility() {
        triggerSetFleetFlagsWithReason(MemFlags.SPREAD_TOFF_HOSTILITY_IF_LOW_IMPACT);
    }
    public void triggerMakeNoRepImpact() {
        triggerSetFleetFlagsWithReason(MemFlags.MEMORY_KEY_LOW_REP_IMPACT,
                                       MemFlags.MEMORY_KEY_NO_REP_IMPACT);
    }
    public void triggerPatrolAllowTransponderOff() {
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_PATROL_ALLOW_TOFF);
    }
    public void triggerDoNotShowFleetDesc() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_DO_NOT_SHOW_FLEET_DESC);
    }
    
    public void triggerFleetForceAutofitOnAllShips() {
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_FORCE_AUTOFIT_ON_NO_AUTOFIT_SHIPS);
    }
    
    public void triggerFleetOnlyEngageableWhenVisibleToPlayer() {
        triggerSetFleetFlag(MemFlags.CAN_ONLY_BE_ENGAGED_WHEN_VISIBLE_TO_PLAYER);
    }
    
    public void triggerFleetNoJump() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_NO_JUMP);
    }
    public void triggerFleetAllowJump() {
        triggerUnsetFleetFlag(MemFlags.MEMORY_KEY_NO_JUMP);
    }
    
    public void triggerSetFleetNotBusy() {
        triggerUnsetFleetFlag(MemFlags.FLEET_BUSY);
    }
    
    public void triggerSetPatrol() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_PATROL_FLEET);
    }
    public void triggerSetFleetHasslePlayer(String hassleType) {
        triggerSetFleetFlag(MemFlags.WILL_HASSLE_PLAYER);
        triggerSetFleetMemoryValue(MemFlags.HASSLE_TYPE, hassleType);
    }
    public void triggerSetFleetExtraSmugglingSuspicion(float extraSuspicion) {
        triggerSetFleetMemoryValue(MemFlags.PATROL_EXTRA_SUSPICION, extraSuspicion);
    }
    public void triggerMakeNonHostileToFaction(String factionId) {
        String flag = MemFlags.MEMORY_KEY_MAKE_NON_HOSTILE + "_" + factionId;
        triggerSetFleetFlag(flag);
    }
    public void triggerMakeHostileToFaction(String factionId) {
        String flag = MemFlags.MEMORY_KEY_MAKE_HOSTILE + "_" + factionId;
        triggerSetFleetFlag(flag);
    }
    public void triggerSetPirateFleet() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_PIRATE);
    }
    public void triggerSetTraderFleet() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_TRADE_FLEET);
    }
    public void triggerSetWarFleet() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_WAR_FLEET);
    }
    public void triggerSetSmugglerFleet() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_SMUGGLER);
    }
    public void triggerFleetAllowLongPursuit() {
        triggerSetFleetFlagPermanent(MemFlags.MEMORY_KEY_ALLOW_LONG_PURSUIT);
    }
    public void triggerFleetPatherAllowTithe() {
        triggerUnsetFleetFlag("$LP_titheAskedFor");
    }
    public void triggerFleetPatherNoDefaultTithe() {
        triggerSetFleetFlagPermanent("$LP_titheAskedFor");
    }
//  public void triggerFleetAllowLongPursuitNotPermanent() {
//      triggerSetFleetFlag(MemFlags.MEMORY_KEY_ALLOW_LONG_PURSUIT);
//  }
    public void triggerFleetUnsetAllowLongPursuit() {
        triggerUnsetFleetFlag(MemFlags.MEMORY_KEY_ALLOW_LONG_PURSUIT);
    }
    public void triggerFleetSetAvoidPlayerSlowly() {
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_AVOID_PLAYER_SLOWLY);
    }
    public void triggerUnsetAvoidPlayerSlowly() {
        triggerUnsetFleetFlag(MemFlags.MEMORY_KEY_AVOID_PLAYER_SLOWLY);
    }
    
    public void triggerSetFleetAlwaysPursue() {
        triggerSetFleetFlag(MemFlags.MEMORY_KEY_MAKE_ALWAYS_PURSUE);
    }
//  public void triggerSetFleetAlwaysPursueNotPermanent() {
//      triggerSetFleetFlag(MemFlags.MEMORY_KEY_MAKE_ALWAYS_PURSUE);
//  }
    public void triggerUnsetFleetAlwaysPursue() {
        triggerUnsetFleetFlag(MemFlags.MEMORY_KEY_MAKE_ALWAYS_PURSUE);
    }
    
    public void triggerSetStandardHostilePirateFlags() {
        triggerSetPirateFleet();
        triggerMakeHostile();
        triggerMakeLowRepImpact();
    }
    public void triggerSetStandardHostileNonPirateFlags() {
        triggerMakeHostile();
        triggerMakeLowRepImpact();
    }
    public void triggerSetStandardAggroPirateFlags() {
        triggerSetPirateFleet();
        triggerMakeHostileAndAggressive();
        triggerMakeLowRepImpact();
    }
    public void triggerSetStandardAggroNonPirateFlags() {
        triggerMakeHostileAndAggressive();
        triggerMakeLowRepImpact();
    }
    public void triggerRemoveAbilities(final String ... abilities) {
        triggerCustomAction(new RemoveAbilitiesAction(abilities));
    }   
    public void triggerAddAbilities(final String ... abilities) {
        triggerCustomAction(new AddAbilitiesAction(abilities));
    }
    public void triggerSetInflater(final FleetInflater inflater) {
        triggerCustomAction(new SetInflaterAction(inflater));
    }
    public void triggerSetRemnantConfig() {
        triggerSetRemnantConfig(false);
    }
    public void triggerSetRemnantConfigDormant() {
        triggerSetRemnantConfig(true);
    }
    public void triggerSetRemnantConfig(boolean dormant) {
        //final long seed = Misc.genRandomSeed();
        long seed = Misc.seedUniquifier() ^ genRandom.nextLong();
        triggerCustomAction(new SetRemnantConfigAction(dormant, seed));
    }
    
    public void triggerSetRemnantConfigActive() {
        triggerSetRemnantConfig();
        triggerAddAbilities(Abilities.EMERGENCY_BURN);
        triggerAddAbilities(Abilities.SENSOR_BURST);
        triggerAddAbilities(Abilities.GO_DARK);
        triggerFleetAllowJump();
    }
    
    public void triggerAddCustomDrop(final CargoAPI cargo) {
        triggerCustomAction(new AddCustomDropAction(cargo));
    }
    public void triggerAddCommodityDrop(String commodityId, int quantity, boolean dropQuantityBasedOnShipsDestroyed) {
        triggerCustomAction(new AddCommodityDropAction(quantity, commodityId, dropQuantityBasedOnShipsDestroyed));
    }
    public void triggerAddCommodityFractionDrop(String commodityId, float fraction) {
        triggerCustomAction(new AddCommodityFractionDropAction(fraction, commodityId));
    }
    public void triggerAddWeaponDrop(final String weaponId, final int quantity) {
        triggerCustomAction(new AddWeaponDropAction(quantity, weaponId));
    }
    public void triggerAddFighterLPCDrop(final String wingId, final int quantity) {
        triggerCustomAction(new AddFighterLPCDropAction(wingId, quantity));
    }
    public void triggerAddHullmodDrop(final String hullmodId) {
        triggerCustomAction(new AddHullmodDropAction(hullmodId));
    }
    public void triggerAddSpecialItemDrop(final String itemId, final String data) {
        triggerCustomAction(new AddSpecialItemDropAction(data, itemId));
    }
    
    
    public void triggerSpawnFleetAtPickedLocation() {
        triggerSpawnFleetAtPickedLocation(null, null);
    }
    public void triggerSpawnFleetAtPickedLocation(final String flag, final String refKey) {
        triggerSpawnFleetAtPickedLocation(200f, flag, refKey);
    }
    public void triggerSpawnFleetAtPickedLocation(final float range, final String flag, final String refKey) {
        triggerCustomAction(new SpawnFleetAtPickedLocationAction(range));
        if (flag != null) {
            triggerSetFleetFlag(flag);
        }
        if (refKey != null) {
            triggerSetFleetMissionRef(refKey);
        }
    }
    public void triggerSpawnFleetNear(final SectorEntityToken entity, final String flag, final String refKey) {
        triggerSpawnFleetNear(entity, 200f, flag, refKey);
    }
    public void triggerSpawnFleetNear(final SectorEntityToken entity, final float range, final String flag, final String refKey) {
        triggerCustomAction(new SpawnFleetNearAction(entity, range));
        if (flag != null) {
            triggerSetFleetFlag(flag);
        }
        if (refKey != null) {
            triggerSetFleetMissionRef(refKey);
        }
    }
    
    public void triggerPickSetLocation(final LocationAPI location, final Vector2f coordinates) {
        triggerCustomAction(new PickSetLocationAction(coordinates, location));
    }
    public void triggerPickLocationInHyperspace(final StarSystemAPI system) {
        triggerCustomAction(new PickLocationInHyperspaceAction(system));
    }
    
    public void triggerPickLocationFromEntityTowardsPlayer(final float arc, final float dist) {
        triggerPickLocationTowardsPlayer(null, arc, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationTowardsPlayer(final SectorEntityToken entity, final float arc, final float dist) {
        triggerPickLocationTowardsPlayer(entity, arc, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationFromEntityTowardsPlayer(final float arc, 
            final float minDist, final float maxDist) {
        triggerPickLocationAwayFromPlayer(null, arc, DEFAULT_MIN_DIST_FROM_PLAYER, minDist, maxDist);
    }
    public void triggerPickLocationTowardsPlayer(final SectorEntityToken entity, final float arc, 
                                                  final float minDist, final float maxDist) {
        triggerPickLocationAwayFromPlayer(entity, arc, DEFAULT_MIN_DIST_FROM_PLAYER, minDist, maxDist);
    }
    public void triggerPickLocationFromEntityTowardsPlayer(final float arc, 
            final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationTowardsPlayerAction(null, arc, minDist, maxDist, minDistFromPlayer));
    }
    public void triggerPickLocationTowardsPlayer(final SectorEntityToken entity, final float arc, 
                                                 final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationTowardsPlayerAction(entity, arc, minDist, maxDist, minDistFromPlayer));
    }
    
    public void triggerPickLocationTowardsEntity(SectorEntityToken entity, float arc, float dist) {
        triggerPickLocationTowardsEntity(entity, arc, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationTowardsEntity(final SectorEntityToken entity, final float arc, 
            final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationTowardsEntityAction(entity, arc, minDist, maxDist, minDistFromPlayer));
    }
    
    
    public void triggerPickLocationFromEntityAwayFromPlayer(final float arc, final float dist) {
        triggerPickLocationAwayFromPlayer(null, arc, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationFromEntityAwayFromPlayer(final float arc, 
            final float minDist, final float maxDist) {
        triggerPickLocationAwayFromPlayer(null, arc, DEFAULT_MIN_DIST_FROM_PLAYER, minDist, maxDist);
    }
    public void triggerPickLocationFromEntityAwayFromPlayer(final float arc, 
            final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationAwayFromPlayerAction(minDist, null, maxDist, arc, minDistFromPlayer));
    }
    public void triggerPickLocationAwayFromPlayer(final SectorEntityToken entity, final float arc, final float dist) {
        triggerPickLocationAwayFromPlayer(entity, arc, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationAwayFromPlayer(final SectorEntityToken entity, final float arc, 
                                                  final float minDist, final float maxDist) {
        triggerPickLocationAwayFromPlayer(entity, arc, DEFAULT_MIN_DIST_FROM_PLAYER, minDist, maxDist);
    }
    public void triggerPickLocationAwayFromPlayer(final SectorEntityToken entity, final float arc, 
                                                  final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationAwayFromPlayerAction(minDist, entity, maxDist, arc, minDistFromPlayer));
    }
    
    public void triggerPickLocationAroundPlayer(final float dist) {
        triggerPickLocationAroundPlayer(dist, dist);
    }
    public void triggerPickLocationAroundPlayer(final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationAroundPlayerAction(maxDist, minDist));
    }
    
    public static float DEFAULT_MIN_DIST_FROM_PLAYER = 3000f;
    public void triggerPickLocationAroundEntity(final float dist) {
        triggerPickLocationAroundEntity(null, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationAroundEntity(final SectorEntityToken entity, final float dist) {
        triggerPickLocationAroundEntity(entity, DEFAULT_MIN_DIST_FROM_PLAYER, dist, dist);
    }
    public void triggerPickLocationAroundEntity(final SectorEntityToken entity, final float minDist, final float maxDist) {
        triggerPickLocationAroundEntity(entity, DEFAULT_MIN_DIST_FROM_PLAYER, minDist, maxDist);
    }
    public void triggerPickLocationAroundEntity(final SectorEntityToken entity, final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationAroundEntityAction(minDist, entity, maxDist, minDistFromPlayer));
    }
    
    public void triggerPickLocationAtInSystemJumpPoint(final StarSystemAPI system) {
        triggerPickLocationAtInSystemJumpPoint(system, DEFAULT_MIN_DIST_FROM_PLAYER);
    }
    public void triggerPickLocationAtInSystemJumpPoint(final StarSystemAPI system, final float minDistFromPlayer) {
        triggerCustomAction(new PickLocationAtInSystemJumpPointAction(system, minDistFromPlayer));
    }
    
    public void triggerPickLocationAtClosestToPlayerJumpPoint(final StarSystemAPI system) {
        triggerPickLocationAtClosestToPlayerJumpPoint(system, DEFAULT_MIN_DIST_FROM_PLAYER);
    }
    public void triggerPickLocationAtClosestToPlayerJumpPoint(final StarSystemAPI system, final float minDistFromPlayer) {
        triggerCustomAction(new PickLocationAtClosestToPlayerJumpPointAction(system, minDistFromPlayer));
    }
    
    public void triggerPickLocationAtClosestToEntityJumpPoint(StarSystemAPI system, SectorEntityToken entity) {
        triggerCustomAction(new PickLocationAtClosestToEntityJumpPointAction(system, entity, 0f));
    }
    public void triggerPickLocationAtClosestToEntityJumpPoint(StarSystemAPI system, SectorEntityToken entity, float minDistFromEntity) {
        triggerCustomAction(new PickLocationAtClosestToEntityJumpPointAction(system, entity, minDistFromEntity));
    }
    
    public void triggerPickLocationWithinArc(final float dir, final float arc,
                            final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerPickLocationWithinArc(null, dir, arc, minDistFromPlayer, minDist, maxDist);
    }
    public void triggerPickLocationWithinArc(final SectorEntityToken entity, final float dir, final float arc,
                                             final float minDistFromPlayer, final float minDist, final float maxDist) {
        triggerCustomAction(new PickLocationWithinArcAction(arc, entity, maxDist, minDist, minDistFromPlayer, dir));
    }
    
    public void triggerSetEntityToPickedJumpPoint() {
        triggerCustomAction(new SetEntityToPickedJumpPoint());
    }
    public void triggerFleetSetPatrolActionText(String patrolText) {
        triggerCustomAction(new FleetSetPatrolActionText(patrolText));
    }
    
    public void triggerFleetSetPatrolLeashRange(float dist) {
        triggerSetFleetMemoryValue(MemFlags.FLEET_PATROL_DISTANCE, dist);
    }
    public void triggerFleetSetTravelActionText(String travelText) {
        triggerCustomAction(new FleetSetTravelActionText(travelText));
    }
    
    public void triggerOrderFleetPatrol(final StarSystemAPI system) {
        triggerCustomAction(new OrderFleetPatrolSystemAction(system));
    }
    public void triggerOrderFleetPatrol(final SectorEntityToken ... patrolPoints) {
        triggerOrderFleetPatrol(null, false, patrolPoints);
    }
    public void triggerOrderFleetPatrol(final boolean randomizeLocation, final SectorEntityToken ... patrolPoints) {
        triggerOrderFleetPatrol(null, randomizeLocation, patrolPoints);
    }
    public void triggerOrderFleetPatrol(final StarSystemAPI system, final boolean randomizeLocation, 
                                        final SectorEntityToken ... patrolPoints) {
        triggerCustomAction(new OrderFleetPatrolPointsAction(patrolPoints, randomizeLocation, system));
    }
    public void triggerOrderFleetPatrol(final StarSystemAPI system, final boolean randomizeLocation, final String ... tags) {
        triggerCustomAction(new OrderFleetPatrolTagsAction(system, randomizeLocation, tags));
    }
    public void triggerOrderExtraPatrolPoints(SectorEntityToken ... points) {
        for (int i = currTrigger.getActions().size() - 1; i >= 0; i--) {
            TriggerAction action = currTrigger.getActions().get(i);
            if (action instanceof OrderFleetPatrolTagsAction) {
                OrderFleetPatrolTagsAction a = (OrderFleetPatrolTagsAction) action;
                if (a.added == null) a.added = new ArrayList<SectorEntityToken>();
                for (SectorEntityToken curr : points) {
                    if (curr != null) {
                        a.added.add(curr);
                    }
                }
                return;
            }
            if (action instanceof OrderFleetPatrolPointsAction) {
                OrderFleetPatrolPointsAction a = (OrderFleetPatrolPointsAction) action;
                for (SectorEntityToken curr : points) {
                    if (curr != null) {
                        a.patrolPoints.add(curr);
                    }
                }
                return;
            }
        }
    }
    
    public void triggerOrderFleetPatrolEntity(boolean moveToNearEntity) {
        triggerCustomAction(new OrderFleetPatrolSpawnedEntity(moveToNearEntity));
    }
    
    public void triggerOrderFleetPatrolHyper(final StarSystemAPI system) {
        triggerOrderFleetPatrol(system, false, system.getHyperspaceAnchor());
    }
 
    public void triggerFleetAddDefeatTrigger(String trigger) {
        triggerCustomAction(new AddFleetDefeatTriggerAction(trigger, false));
    }
    
    public void triggerFleetAddDefeatTriggerPermanent(String trigger) {
        triggerCustomAction(new AddFleetDefeatTriggerAction(trigger, true));
    }
    
    public void triggerMakeFleetGoAwayAfterDefeat() {
        triggerCustomAction(new AddFleetDefeatTriggerAction("GoAwayAfterDefeatTrigger", true));
    }
    
    public void triggerOrderFleetInterceptPlayer() {
        triggerOrderFleetInterceptPlayer(false, true);
    }
    public void triggerOrderFleetInterceptPlayer(boolean makeHostile, boolean allowLongPursuit) {
        triggerCustomAction(new OrderFleetInterceptPlayerAction(makeHostile));
        if (allowLongPursuit) {
            triggerFleetAllowLongPursuit();
        }
    }
    
    public void triggerOrderFleetMaybeEBurn() {
        triggerOrderFleetEBurn(0.5f);
    }
    public void triggerOrderFleetEBurn(float probabilityToEBurn) {
        if (genRandom.nextFloat() < probabilityToEBurn) {
            triggerCustomAction(new OrderFleetEBurn());
        }
    }
    
    public void triggerOrderFleetAttackLocation(final SectorEntityToken entity) {
        triggerOrderFleetPatrol(null, false, entity);
    }
    
    public void triggerFleetNoAutoDespawn() {
        triggerCustomAction(new FleetNoAutoDespawnAction());
    }
    
    public void triggerFleetStopPursuingPlayerUnlessInStage(Object ... stages) {
        triggerCustomAction(new OrderFleetStopPursuingPlayerUnlessInStage(this, stages));
    }
    
    public void triggerFleetInterceptPlayerWithinRange(boolean mustBeStrongEnoughToFight, float maxRange, 
                                            boolean repeatable, float repeatDelay, Object ... stages) {
        triggerCustomAction(
                new OrderFleetInterceptNearbyPlayerInStage(this, mustBeStrongEnoughToFight, maxRange, repeatable, repeatDelay, stages));
        triggerFleetStopPursuingPlayerUnlessInStage(stages);
    }
    
    public void triggerFleetInterceptPlayerNearby(boolean mustBeStrongEnoughToFight, Object ... stages) {
        triggerFleetInterceptPlayerWithinRange(mustBeStrongEnoughToFight, 500f, true, 5f, stages);
    }
    
    public void triggerFleetInterceptPlayerOnSight(boolean mustBeStrongEnoughToFight,Object ... stages) {
        triggerFleetInterceptPlayerWithinRange(mustBeStrongEnoughToFight, 10000f, true, 5f, stages);
    }
    
    
    public static Vector2f pickLocationWithinArc(Random random, final SectorEntityToken entity, final float dir, final float arc,
            final float minDistToPlayer, final float minDist, final float maxDist) {
        float angleIncr = 10f;
        float distIncr = (maxDist - minDist) / 5f;
        if (distIncr < 1000f) {
            distIncr = (maxDist - minDist) / 2f;
        }
        if (distIncr < 1) distIncr = 1;
 
 
        WeightedRandomPicker<Vector2f> picker = new WeightedRandomPicker<Vector2f>(random);
        for (float currAngle = dir - arc / 2f; currAngle < dir + arc / 2f; currAngle += angleIncr) {
            for (float dist = minDist; dist <= maxDist; dist += distIncr) {
                Vector2f loc = Misc.getUnitVectorAtDegreeAngle(currAngle);
                loc.scale(dist);
                Vector2f.add(entity.getLocation(), loc, loc);
                picker.add(loc);
            }
        }
 
        WeightedRandomPicker<Vector2f> copy = new WeightedRandomPicker<Vector2f>(random);
        copy.addAll(picker);
        
        
        StarSystemAPI system = entity.getStarSystem();
        CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
        Vector2f pick = null;
        LocationAPI containingLocation = entity.getContainingLocation();
 
        while (!picker.isEmpty()) {
            Vector2f loc = picker.pickAndRemove();
            if (isNearCorona(system, loc)) continue;
 
            float distToPlayer = Float.MAX_VALUE;
            if (playerFleet != null && playerFleet.getContainingLocation() == containingLocation) {
                distToPlayer = Misc.getDistance(playerFleet.getLocation(), loc);
                if (distToPlayer < minDistToPlayer) {
                    continue;
                }
            }
            pick = loc;
        }
 
        if (pick == null) {
            pick = copy.pick();
        }
 
        float distToPlayer = Float.MAX_VALUE;
        if (playerFleet != null && playerFleet.getContainingLocation() == containingLocation) {
            distToPlayer = Misc.getDistance(playerFleet.getLocation(), pick);
            if (distToPlayer < minDistToPlayer) {
                Vector2f away = Misc.getUnitVectorAtDegreeAngle(
                        Misc.getAngleInDegrees(playerFleet.getLocation(), pick));
                away.scale(minDistToPlayer);
                Vector2f.add(playerFleet.getLocation(), away, away);
                pick = away;
            }
        }
        
        return pick;
    }
    
    public static boolean isNearCorona(StarSystemAPI system, Vector2f loc) {
        if (system == null) return false;
        for (PlanetAPI planet : system.getPlanets()) {
            if (!planet.isStar()) continue;
            StarCoronaTerrainPlugin corona = Misc.getCoronaFor(planet);
            if (corona == null) continue;
            float dist = Misc.getDistance(planet.getLocation(), loc);
            float radius = corona.getParams().middleRadius + corona.getParams().bandWidthInEngine * 0.5f;
            if (dist < radius + 500f) {
                return true;
            }
        }
        return false;
    }
    
    
    public void triggerCustomAction(TriggerAction action) {
        currTrigger.getActions().add(action);
    }
    
    
    
    
    
 
    protected transient MissionTrigger currTrigger = null;
    public void beginGlobalFlagTrigger(String flag, Object ... stages) {
        beginCustomTrigger(new GlobalBooleanChecker(flag), stages); 
    }
    public void beginDaysElapsedTrigger(float days, Object ... stages) {
        beginCustomTrigger(new DaysElapsedChecker(days, this), stages); 
    }
    public void beginDaysElapsedTrigger(float days, Object stage, Object ... stages) {
        beginCustomTrigger(new DaysElapsedChecker(days, getData(stage)), stages); 
    }
    public void beginInCommRelayRangeTrigger(Object ... stages) {
        beginCustomTrigger(new InCommRelayRangeChecker(), stages);
    }
    public void beginEnteredLocationTrigger(LocationAPI location, Object ... stages) {
        beginCustomTrigger(new EnteredLocationChecker(location), stages);
    }
    public void beginInRangeOfEntityTrigger(SectorEntityToken entity, float range, Object ... stages) {
        beginCustomTrigger(new InRangeOfEntityChecker(entity, range), stages);
    }
//  public void beginWithinHyperspaceRangeTrigger(SectorEntityToken entity, float rangeLY, Object ... stages) {
//      beginWithinHyperspaceRangeTrigger(entity, rangeLY, false, stages);
//  }
    public void beginWithinHyperspaceRangeTrigger(SectorEntityToken entity, float rangeLY, boolean requirePlayerInHyperspace, 
                                    Object ... stages) {
        beginCustomTrigger(new InHyperRangeOfEntityChecker(entity, rangeLY, requirePlayerInHyperspace), stages);
    }
    
    public void beginWithinHyperspaceRangeTrigger(StarSystemAPI system, float rangeLY, boolean requirePlayerInHyperspace, 
                                                  Object ... stages) {
        beginWithinHyperspaceRangeTrigger(system.getCenter(), rangeLY, requirePlayerInHyperspace, stages);
    }
    
//  public void beginWithinHyperspaceRangeTrigger(MarketAPI market, float rangeLY, Object ... stages) {
//      beginWithinHyperspaceRangeTrigger(market, rangeLY, false, stages);
//  }
    public void beginWithinHyperspaceRangeTrigger(MarketAPI market, float rangeLY, boolean requirePlayerInHyperspace,
                                Object ... stages) {
        beginCustomTrigger(new InHyperRangeOfEntityChecker(market.getPrimaryEntity(), rangeLY, requirePlayerInHyperspace), stages);
    }
    
    public void beginStageTrigger(Object ... stages) {
        beginCustomTrigger(new AlwaysTrueChecker(), stages);
    }
    public void beginCustomTrigger(ConditionChecker condition, Object ... stages) {
        checkExistingTrigger();
        
        currTrigger = new MissionTrigger();
        currTrigger.setCondition(condition);
        if (stages != null) {
            for (Object stage : stages) {
                currTrigger.getStages().add(stage);
            }
        }
    }
    
    
    public void endTrigger() {
        if (currTrigger == null) {
            throw new RuntimeException("endTrigger() called without a corresponding beginTrigger()");
        }
        triggers.add(currTrigger);
        currTrigger = null;
    }
    protected void checkExistingTrigger() {
        if (currTrigger != null) throw new RuntimeException("Already began a trigger, call endTrigger() to finish it");
    }
    
    public MissionTrigger getCurrTrigger() {
        return currTrigger;
    }
    public void setCurrTrigger(MissionTrigger currTrigger) {
        this.currTrigger = currTrigger;
    }
    
    
    public void triggerSpawnEntity(final String entityId, LocData data) {
        triggerCustomAction(new SpawnEntityAction(entityId, data));
    }
    
    public void triggerSpawnDebrisField(float radius, float density, LocData data) {
        triggerCustomAction(new SpawnDebrisFieldAction(radius, density, data));
    }
    
    public void triggerDespawnEntity(SectorEntityToken entity) {
        triggerCustomAction(new DespawnEntityAction(entity));
    }
    
 
    public void triggerSpawnDerelictHull(String hullId, LocData data) {
        triggerCustomAction(new SpawnDerelictAction(hullId, null, null, data));
    }
    
    public void triggerSpawnDerelict(String factionId, DerelictType type, LocData data) {
        triggerCustomAction(new SpawnDerelictAction(null, factionId, type, data));
    }
    public void triggerSpawnDerelict(DerelictType type, LocData data) {
        triggerCustomAction(new SpawnDerelictAction(type, data));
    }
    
    public void triggerSpawnDerelict(DerelictShipData shipData, LocData data) {
        triggerCustomAction(new SpawnDerelictAction(shipData, data));
    }
    
    public void triggerSpawnShipGraveyard(String factionId, int minShips, int maxShips, LocData data) {
        triggerCustomAction(new SpawnShipGraveyardAction(factionId, minShips, maxShips, data));
    }
    
    public void triggerMakeMissionNodeDiscoverable() {
        triggerCustomAction(new MakeDiscoverableAction(1000f, 200f));
    }
    public void triggerMakeDiscoverable(float range, float xp) {
        triggerCustomAction(new MakeDiscoverableAction(range, xp));
    }
    
    public void triggerFleetAddTags(String ... tags) {
        triggerCustomAction(new AddTagsAction(tags));
    }
    
    public void triggerAddTags(SectorEntityToken entity, String ... tags) {
        triggerCustomAction(new GenericAddTagsAction(entity, tags));
    }
    public void triggerRemoveTags(SectorEntityToken entity, String ... tags) {
        triggerCustomAction(new GenericRemoveTagsAction(entity, tags));
    }
    public void triggerMakeNonStoryCritical(MemoryAPI ... memoryArray) {
        triggerCustomAction(new MakeNonStoryCriticalAction(memoryArray));
    }
    public void triggerMakeNonStoryCritical(String ... markets) {
        for (String id : markets) {
            MarketAPI market = Global.getSector().getEconomy().getMarket(id);
            if (market != null) {
                triggerCustomAction(new MakeNonStoryCriticalAction(market.getMemory()));
            }
        }
    }
    public void triggerMakeNonStoryCritical(MarketAPI ... markets) {
        for (MarketAPI market : markets) {
            triggerCustomAction(new MakeNonStoryCriticalAction(market.getMemory()));
        }
    }
    
    public void triggerFleetAddCommanderSkill(String skill, int level) {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa != null && cfa.params != null && cfa.params.commander != null) {
            cfa.params.commander.getStats().setSkillLevel(skill, level);
        } else {
            triggerCustomAction(new AddCommanderSkillAction(skill, level));
        }
    }
    
    public void triggerMakeAllFleetFlagsPermanent() {
        triggerCustomAction(new MakeFleetFlagsPermanentAction(true));
    }
    public void triggerUndoMakeAllFleetFlagsPermanent() {
        triggerCustomAction(new MakeFleetFlagsPermanentAction(false));
    }
    
    
    public static CampaignFleetAPI createFleet(FleetSize size, FleetQuality quality, 
            OfficerNum oNum, OfficerQuality oQuality, String factionId, String fleetFactionId, String type, Vector2f locInHyper) {
        CreateFleetAction action = new CreateFleetAction(type, locInHyper, size, quality, factionId);
        action.oNum = oNum;
        action.oQuality = oQuality;
        action.faction = fleetFactionId;
        TriggerActionContext context = new TriggerActionContext(null);
        action.doAction(context);
        return context.fleet;
    }
    
    
    public void triggerCreateSmallPatrolAroundMarket(MarketAPI market, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(market, null, stage, FleetSize.VERY_SMALL, FleetTypes.PATROL_MEDIUM, extraSuspicion);
    }
    public void triggerCreateMediumPatrolAroundMarket(MarketAPI market, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(market, null, stage, FleetSize.MEDIUM, FleetTypes.PATROL_MEDIUM, extraSuspicion);
    }
    public void triggerCreateLargePatrolAroundMarket(MarketAPI market, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(market, null, stage, FleetSize.LARGE, FleetTypes.PATROL_LARGE, extraSuspicion);
    }
    public void triggerCreateSmallPatrol(MarketAPI from, String factionId, SectorEntityToken entityToPatrol, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(from, factionId, entityToPatrol, stage, FleetSize.VERY_SMALL, FleetTypes.PATROL_MEDIUM, extraSuspicion);
    }
    public void triggerCreateMediumPatrol(MarketAPI from, String factionId, SectorEntityToken entityToPatrol, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(from, factionId, entityToPatrol, stage, FleetSize.MEDIUM, FleetTypes.PATROL_MEDIUM, extraSuspicion);
    }
    public void triggerCreateLargePatrol(MarketAPI from, String factionId, SectorEntityToken entityToPatrol, Object stage, float extraSuspicion) {
        triggerCreatePatrolAroundMarket(from, factionId, entityToPatrol, stage, FleetSize.LARGE, FleetTypes.PATROL_LARGE, extraSuspicion);
    }
    public void triggerCreatePatrolAroundMarket(MarketAPI market, SectorEntityToken entityToPatrol, 
                                                Object stage, FleetSize size, String fleetType,
                                                float extraSuspicion) {
        triggerCreatePatrolAroundMarket(market, null, entityToPatrol, stage, size, fleetType, extraSuspicion);
    }
    public void triggerCreatePatrolAroundMarket(MarketAPI market, String factionId, SectorEntityToken entityToPatrol, 
                                Object stage, FleetSize size, String fleetType,
                                float extraSuspicion) {
        if (entityToPatrol == null) entityToPatrol = market.getPrimaryEntity();
        if (factionId == null) factionId = market.getFactionId();
        
        beginWithinHyperspaceRangeTrigger(entityToPatrol, 1f, false, stage);
        triggerCreateFleet(size, FleetQuality.DEFAULT, factionId, fleetType, entityToPatrol);
        triggerAutoAdjustFleetStrengthModerate();
        triggerMakeAllFleetFlagsPermanent();
        FactionAPI faction = Global.getSector().getFaction(factionId);
        if (faction.getCustomBoolean(Factions.CUSTOM_PIRATE_BEHAVIOR)) {
            triggerSetPirateFleet();
        } else {
            triggerSetPatrol();
        }
        triggerPickLocationAroundEntity(entityToPatrol, 100f);
        triggerSpawnFleetAtPickedLocation(null, null);
        triggerOrderFleetPatrol(entityToPatrol);
        triggerSetFleetExtraSmugglingSuspicion(extraSuspicion);
        triggerSetFleetNotBusy(); // so that it can be distracted and in general acts like a normal patrol
        if (market != null) {
            triggerSetFleetMemoryValue(MemFlags.MEMORY_KEY_SOURCE_MARKET, market.getId());
        }
        endTrigger();
    }
    
    
    public static enum ComplicationSpawn {
        APPROACHING_OR_ENTERING,
        APPROACHING_SYSTEM,
        ENTERING_SYSTEM,
        EXITING_SYSTEM,
    }
    public static enum ComplicationRepImpact{
        NONE,
        LOW,
        FULL,
    }
    
    public ComplicationSpawn pickComplicationSpawnType() {
        WeightedRandomPicker<ComplicationSpawn> picker = new WeightedRandomPicker<ComplicationSpawn>(genRandom);
        picker.add(ComplicationSpawn.APPROACHING_SYSTEM);
        picker.add(ComplicationSpawn.ENTERING_SYSTEM);
        picker.add(ComplicationSpawn.EXITING_SYSTEM);
        return picker.pick();
    }
    
    public void triggerRandomizeFleetProperties() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        
        if (genRandom.nextFloat() < 0.33f && cfa.fSize != FleetSize.TINY && getQuality() > 0.25f) {
            // less ships, better quality and more officers
            cfa.fSize = cfa.fSize.prev();
            if (cfa.fQuality == null) cfa.fQuality = FleetQuality.DEFAULT;
            cfa.fQuality = cfa.fQuality.next();
            
            if (cfa.oNum == null) cfa.oNum = OfficerNum.DEFAULT;
            cfa.oNum = cfa.oNum.next();
        } else if (genRandom.nextFloat() < 0.5f && cfa.fSize != FleetSize.MAXIMUM) {
            // more ships, lower quality, same officers
            cfa.fSize = cfa.fSize.next();
            if (cfa.fQuality == null) cfa.fQuality = FleetQuality.DEFAULT;
            cfa.fQuality = cfa.fQuality.prev();
        }
        
    }
    
    @SuppressWarnings("rawtypes")
    public void triggerComplicationBegin(Object stage, ComplicationSpawn spawnType, StarSystemAPI system,
                        String factionId,
                        String thing,
                        String thingItOrThey,
                        String thingDesc,
                        int paymentOffered,
                        boolean aggressiveIfDeclined,
                        ComplicationRepImpact repImpact,
                        String failTrigger) {
        if (spawnType == ComplicationSpawn.APPROACHING_OR_ENTERING) spawnType = pickComplicationSpawnType();
        
        if ("them".equals(thingItOrThey)) thingItOrThey = "they";
        
        if (spawnType == ComplicationSpawn.APPROACHING_SYSTEM) {
            beginWithinHyperspaceRangeTrigger(system.getCenter(), 3f, true, stage);
        } else if (spawnType == ComplicationSpawn.ENTERING_SYSTEM) {
            beginEnteredLocationTrigger(system, stage);
        } else if (spawnType == ComplicationSpawn.EXITING_SYSTEM) {
            //beginEnteredLocationTrigger(Global.getSector().getHyperspace(), stage);
            // so that it doesn't trigger if the player exits the system through alternate means and is far away
            beginWithinHyperspaceRangeTrigger(system, 1f, true, stage);
        }
        
        triggerCreateFleet(FleetSize.LARGE, FleetQuality.DEFAULT, factionId, FleetTypes.PATROL_MEDIUM, system);
        
        triggerSetFleetMissionRef("$" + getMissionId() + "_ref");
        triggerSetFleetMissionRef("$fwt_ref");
        
        FactionAPI faction = Global.getSector().getFaction(factionId);
        if (aggressiveIfDeclined) {
            triggerSetPirateFleet();
            triggerMakeHostileAndAggressive();
        }
        
        if (repImpact == ComplicationRepImpact.LOW) {
            triggerMakeLowRepImpact();
        } else if (repImpact == ComplicationRepImpact.NONE) {
            triggerMakeNoRepImpact();
        }
        
        triggerFleetAllowLongPursuit();
        triggerSetFleetAlwaysPursue();
        
        if (faction.getCustomBoolean(Factions.CUSTOM_SPAWNS_AS_INDEPENDENT)) {
            triggerSetFleetFaction(Factions.INDEPENDENT);
            triggerSetFleetMemoryValue("$fwt_originalFaction", factionId);
        }
        
        
        if (spawnType == ComplicationSpawn.APPROACHING_SYSTEM) {
            triggerPickLocationTowardsPlayer(system.getHyperspaceAnchor(), 90f, getUnits(1.5f));
        } else if (spawnType == ComplicationSpawn.ENTERING_SYSTEM) {
            triggerPickLocationTowardsPlayer(system.getCenter(), 90, 2000);
        } else if (spawnType == ComplicationSpawn.EXITING_SYSTEM) {
            triggerPickLocationAroundPlayer(2000);
        }
        
        triggerOrderFleetInterceptPlayer();
        triggerFleetStopPursuingPlayerUnlessInStage(stage);
        
        triggerSpawnFleetAtPickedLocation("$fwt_wantsThing", null);
        triggerSetFleetMemoryValue("$fwt_aggressive", aggressiveIfDeclined);
        triggerSetFleetMemoryValue("$fwt_thing", getWithoutArticle(thing));
        triggerSetFleetMemoryValue("$fwt_Thing", Misc.ucFirst(getWithoutArticle(thing)));
        triggerSetFleetMemoryValue("$fwt_theThing", thing);
        triggerSetFleetMemoryValue("$fwt_TheThing", Misc.ucFirst(thing));
        triggerSetFleetMemoryValue("$fwt_payment", Misc.getWithDGS(paymentOffered));
        triggerSetFleetMemoryValue("$fwt_itOrThey", thingItOrThey);
        triggerSetFleetMemoryValue("$fwt_ItOrThey", Misc.ucFirst(thingItOrThey));
        
        String thingItOrThem = "them";
        if ("it".equals(thingItOrThey)) thingItOrThem = "it";
        triggerSetFleetMemoryValue("$fwt_itOrThem", thingItOrThem);
        triggerSetFleetMemoryValue("$fwt_ItOrThem", Misc.ucFirst(thingItOrThem));
        
        triggerSetFleetMemoryValue("$fwt_thingDesc", thingDesc);
        triggerSetFleetMemoryValue("$fwt_ThingDesc", Misc.ucFirst(thingDesc));
        
        if (failTrigger == null) {
            failTrigger = "FWTDefaultFailTrigger";
        }
        triggerSetFleetMemoryValue("$fwt_missionFailTrigger", failTrigger);
        
        triggerFleetMakeImportant(null, (Enum) stage);
        
        //endTrigger();
    }
    
    public void triggerComplicationEnd(boolean randomizeAndAdjustFleetSize) {
        if (randomizeAndAdjustFleetSize) {
            triggerRandomizeFleetProperties();
            
            setUseQualityInsteadOfQualityFraction(true);
            triggerAutoAdjustFleetStrengthMajor();
            setUseQualityInsteadOfQualityFraction(false);
        }
        autoAdjustFleetTypeName();
        
        endTrigger();
    }
    
    public void autoAdjustFleetTypeName() {
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa.params.fleetType != null && cfa.fSizeOverride != null &&
                (cfa.params.fleetType.equals(FleetTypes.PATROL_SMALL) ||
                 cfa.params.fleetType.equals(FleetTypes.PATROL_MEDIUM) ||
                 cfa.params.fleetType.equals(FleetTypes.PATROL_LARGE))) {
            if (cfa.fSizeOverride <= 0.2f) {
                cfa.params.fleetType = FleetTypes.PATROL_SMALL; 
            } else if (cfa.fSizeOverride < 0.7f) {
                cfa.params.fleetType = FleetTypes.PATROL_MEDIUM;    
            } else {
                cfa.params.fleetType = FleetTypes.PATROL_LARGE; 
            }
        } else if (cfa.params.fleetType != null && cfa.fSizeOverride != null &&
                (cfa.params.fleetType.equals(FleetTypes.SCAVENGER_SMALL) ||
                        cfa.params.fleetType.equals(FleetTypes.SCAVENGER_MEDIUM) ||
                        cfa.params.fleetType.equals(FleetTypes.SCAVENGER_LARGE))) {
            if (cfa.fSizeOverride <= 0.2f) {
                cfa.params.fleetType = FleetTypes.SCAVENGER_SMALL;  
            } else if (cfa.fSizeOverride < 0.7f) {
                cfa.params.fleetType = FleetTypes.SCAVENGER_MEDIUM; 
            } else {
                cfa.params.fleetType = FleetTypes.SCAVENGER_LARGE;  
            }
        }
    }
    
    
    public void triggerFleetSetWarnAttack(String warnCommsTrigger, String attackCommsTrigger, Object ... stages) {
        triggerSetFleetFlag("$warnAttack", stages);
        triggerSetFleetMemoryValue("$warnAttack_warningComms", warnCommsTrigger);
        triggerSetFleetMemoryValue("$warnAttack_attackComms", attackCommsTrigger);
        triggerFleetInterceptPlayerOnSight(true, stages);
        
        CreateFleetAction cfa = getPreviousCreateFleetAction();
        if (cfa != null && cfa.params != null && cfa.params.factionId != null) {
            triggerSetFleetMemoryValue("$warnAttack_factionId", cfa.params.factionId);
        }
    }
    
    public void triggerFleetAddTugsFlag(int tugs) {
        triggerCustomAction(new FleetAddTugs(tugs));
    }
 
    public void triggerFleetMakeFaster(boolean navigationSkill, int numTugs, boolean allowLongPursuit) {
        if (navigationSkill) {
            triggerFleetAddCommanderSkill(Skills.NAVIGATION, 1);
        }
        if (numTugs > 0) {
            triggerFleetAddTugsFlag(numTugs);
        }
        if (allowLongPursuit) {
            triggerFleetAllowLongPursuit();
        }
    }
    
    public static void addTugsToFleet(CampaignFleetAPI fleet, int tugs, Random random) {
        //if (true) return;
        
        int max = Global.getSettings().getInt("maxShipsInAIFleet");
        if (fleet.getNumMembersFast() + tugs > max) {
            FleetFactoryV3.pruneFleet(max - tugs, 0, fleet, 100000, random);
        }
        
        FactionAPI faction = fleet.getFaction();
        for (int i = 0; i < tugs; i++) {
            ShipPickParams params = new ShipPickParams(ShipPickMode.ALL);
            List<ShipRolePick> picks = faction.pickShip(ShipRoles.TUG, params, null, random);
            for (ShipRolePick pick : picks) {
                FleetMemberAPI member = fleet.getFleetData().addFleetMember(pick.variantId);
                member.updateStats();
                member.getRepairTracker().setCR(member.getRepairTracker().getMaxCR());
                break;
            }
        }
    }
    
    public void setFleetDamageTaken(float damage) {
        getPreviousCreateFleetAction().damage = damage;
    }
    
    
    public void setFleetSource(MarketAPI... preferred) {
        if (preferred == null) return;
        
        for (MarketAPI market : preferred) {
            if (!market.hasCondition(Conditions.DECIVILIZED)) {
                getPreviousCreateFleetAction().params.setSource(market, true);
                break;
            }
        }
    }
    
    public void setFleetSource(String ... preferred) {
        if (preferred == null) return;
        
        for (String id : preferred) {
            MarketAPI market = Global.getSector().getEconomy().getMarket(id);
            if (market != null && !market.hasCondition(Conditions.DECIVILIZED)) {
                getPreviousCreateFleetAction().params.setSource(market, true);
                break;
            }
        }
    }
}