MarketCMD.java

Go to the documentation of this file.

package com.fs.starfarer.api.impl.campaign.rulecmd.salvage;
 
import java.awt.Color;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
 
import org.lwjgl.input.Keyboard;
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.EveryFrameScript;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.campaign.BattleAPI;
import com.fs.starfarer.api.campaign.BattleAPI.BattleSide;
import com.fs.starfarer.api.campaign.CampaignFleetAPI;
import com.fs.starfarer.api.campaign.CargoAPI;
import com.fs.starfarer.api.campaign.CoreInteractionListener;
import com.fs.starfarer.api.campaign.FactionAPI;
import com.fs.starfarer.api.campaign.GroundRaidTargetPickerDelegate;
import com.fs.starfarer.api.campaign.InteractionDialogAPI;
import com.fs.starfarer.api.campaign.InteractionDialogPlugin;
import com.fs.starfarer.api.campaign.OptionPanelAPI;
import com.fs.starfarer.api.campaign.RepLevel;
import com.fs.starfarer.api.campaign.RuleBasedDialog;
import com.fs.starfarer.api.campaign.SectorEntityToken;
import com.fs.starfarer.api.campaign.TextPanelAPI;
import com.fs.starfarer.api.campaign.ai.CampaignFleetAIAPI.ActionType;
import com.fs.starfarer.api.campaign.econ.Industry;
import com.fs.starfarer.api.campaign.econ.MarketAPI;
import com.fs.starfarer.api.campaign.econ.MonthlyReport;
import com.fs.starfarer.api.campaign.listeners.GroundRaidObjectivesListener.RaidResultData;
import com.fs.starfarer.api.campaign.listeners.ListenerUtil;
import com.fs.starfarer.api.campaign.rules.MemoryAPI;
import com.fs.starfarer.api.characters.OfficerDataAPI;
import com.fs.starfarer.api.characters.PersonAPI;
import com.fs.starfarer.api.combat.BattleCreationContext;
import com.fs.starfarer.api.combat.MutableStat;
import com.fs.starfarer.api.combat.MutableStat.StatMod;
import com.fs.starfarer.api.combat.StatBonus;
import com.fs.starfarer.api.fleet.FleetMemberAPI;
import com.fs.starfarer.api.impl.campaign.CoreReputationPlugin.CustomRepImpact;
import com.fs.starfarer.api.impl.campaign.CoreReputationPlugin.RepActionEnvelope;
import com.fs.starfarer.api.impl.campaign.CoreReputationPlugin.RepActions;
import com.fs.starfarer.api.impl.campaign.DebugFlags;
import com.fs.starfarer.api.impl.campaign.FleetEncounterContext;
import com.fs.starfarer.api.impl.campaign.FleetInteractionDialogPluginImpl;
import com.fs.starfarer.api.impl.campaign.FleetInteractionDialogPluginImpl.BaseFIDDelegate;
import com.fs.starfarer.api.impl.campaign.FleetInteractionDialogPluginImpl.FIDConfig;
import com.fs.starfarer.api.impl.campaign.MilitaryResponseScript;
import com.fs.starfarer.api.impl.campaign.MilitaryResponseScript.MilitaryResponseParams;
import com.fs.starfarer.api.impl.campaign.RuleBasedInteractionDialogPluginImpl;
import com.fs.starfarer.api.impl.campaign.econ.RecentUnrest;
import com.fs.starfarer.api.impl.campaign.econ.impl.PopulationAndInfrastructure;
import com.fs.starfarer.api.impl.campaign.graid.DisruptIndustryRaidObjectivePluginImpl;
import com.fs.starfarer.api.impl.campaign.graid.GroundRaidObjectivePlugin;
import com.fs.starfarer.api.impl.campaign.ids.Commodities;
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.Industries;
import com.fs.starfarer.api.impl.campaign.ids.MemFlags;
import com.fs.starfarer.api.impl.campaign.ids.Sounds;
import com.fs.starfarer.api.impl.campaign.ids.Stats;
import com.fs.starfarer.api.impl.campaign.ids.Strings;
import com.fs.starfarer.api.impl.campaign.ids.Tags;
import com.fs.starfarer.api.impl.campaign.intel.BaseIntelPlugin;
import com.fs.starfarer.api.impl.campaign.intel.deciv.DecivTracker;
import com.fs.starfarer.api.impl.campaign.population.CoreImmigrationPluginImpl;
import com.fs.starfarer.api.impl.campaign.procgen.StarSystemGenerator;
import com.fs.starfarer.api.impl.campaign.rulecmd.AddRemoveCommodity;
import com.fs.starfarer.api.impl.campaign.rulecmd.BaseCommandPlugin;
import com.fs.starfarer.api.impl.campaign.rulecmd.FireAll;
import com.fs.starfarer.api.impl.campaign.rulecmd.FireBest;
import com.fs.starfarer.api.impl.campaign.rulecmd.SetStoryOption;
import com.fs.starfarer.api.impl.campaign.rulecmd.SetStoryOption.BaseOptionStoryPointActionDelegate;
import com.fs.starfarer.api.impl.campaign.rulecmd.SetStoryOption.StoryOptionParams;
import com.fs.starfarer.api.impl.campaign.rulecmd.ShowDefaultVisual;
import com.fs.starfarer.api.impl.campaign.shared.SharedData;
import com.fs.starfarer.api.impl.campaign.terrain.HyperspaceTerrainPlugin;
import com.fs.starfarer.api.ui.LabelAPI;
import com.fs.starfarer.api.ui.TooltipMakerAPI;
import com.fs.starfarer.api.ui.TooltipMakerAPI.StatModValueGetter;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.util.Misc.Token;
 
public class MarketCMD extends BaseCommandPlugin {
 
    public static enum RaidType {
        CUSTOM_ONLY,
        VALUABLE,
        DISRUPT,
    }
    
    public static enum BombardType {
        TACTICAL,
        SATURATION,
    }
    
    public static enum RaidDangerLevel {
        NONE("None", "None", Misc.getPositiveHighlightColor(), 0f, 60f, 1),
        MINIMAL("Minimal", "Minimal", Misc.getPositiveHighlightColor(), 0.02f, 50f, 1),
        LOW("Low", "Light", Misc.getPositiveHighlightColor(), 0.04f, 40f, 2),
        MEDIUM("Medium", "Moderate", Misc.getHighlightColor(), 0.08f, 30f, 3),
        HIGH("High", "Heavy", Misc.getNegativeHighlightColor(), 0.16f, 20f, 5),
        EXTREME("Extreme", "Extreme", Misc.getNegativeHighlightColor(), 0.32f, 10f, 7);
        
        private static RaidDangerLevel [] vals = values();
        
        public String name;
        public String lossesName;
        public Color color;
        public float marineLossesMult;
        public int marineTokens;
        public float disruptionDays;
        private RaidDangerLevel(String name, String lossesName, Color color, float marineLossesMult, float disruptionDays, int marineTokens) {
            this.name = name;
            this.lossesName = lossesName;
            this.color = color;
            this.marineLossesMult = marineLossesMult;
            this.disruptionDays = disruptionDays;
            this.marineTokens = marineTokens;
        }
        
        public RaidDangerLevel next() {
            int index = this.ordinal() + 1;
            if (index >= vals.length) index = vals.length - 1;
            return vals[index];
        }
        public RaidDangerLevel prev() {
            int index = this.ordinal() - 1;
            if (index < 0) index = 0;
            return vals[index];
        }
    }
    
    public static class TempData {
        //public boolean canSurpriseRaid;
        //public boolean isSurpriseRaid;
        public boolean canRaid;
        public boolean canBombard;
        
        public int bombardCost;
        
        public int marinesLost;
        
        //public boolean canFail = false;
        //public float failProb = 0f;
        
        public float raidMult;
        
        public float attackerStr;
        public float defenderStr;
        
        public boolean nonMarket = false;
        public boolean secret = false;
        
        public RaidType raidType = null;
        public BombardType bombardType = null;
        public CargoAPI raidLoot;
        public int xpGained;
        public Industry target = null;
        public List<FactionAPI> willBecomeHostile = new ArrayList<FactionAPI>();
        public List<Industry> bombardmentTargets = new ArrayList<Industry>();
        public List<GroundRaidObjectivePlugin> objectives = new ArrayList<GroundRaidObjectivePlugin>();
        public String contText;
        public String raidGoBackTrigger;
        public String raidContinueTrigger;
    }
    
    public static int HOSTILE_ACTIONS_TIMEOUT_DAYS = 60;
    public static int TACTICAL_BOMBARD_TIMEOUT_DAYS = 120;
    public static int SATURATION_BOMBARD_TIMEOUT_DAYS = 365;
    
    public static int MIN_MARINE_TOKENS = 1;
    public static float RE_PER_MARINE_TOKEN = 0.1f;
    public static int MAX_MARINE_TOKENS = 10;
    public static float LOSS_REDUCTION_PER_RESERVE_TOKEN = 0.05f;
    public static float LOSS_INCREASE_PER_RAID = 0.5f;
    public static float MAX_MARINE_LOSSES = 0.8f;
 
    public static float MIN_RE_TO_REDUCE_MARINE_LOSSES = 0.5f;
    public static float MAX_MARINE_LOSS_REDUCTION_MULT = 0.05f;
    
    // for causing deficit; higher value means less units need to be raided to cause same deficit   
    public static float ECON_IMPACT_MULT = 1f;
    
    public static float QUANTITY_MULT_NORMAL = 1f; 
    public static float QUANTITY_MULT_EXCESS = 2f; 
    public static float QUANTITY_MULT_DEFICIT = -0.5f; 
    public static float QUANTITY_MULT_OVERALL = 0.1f; 
    
    
    public static String ENGAGE = "mktEngage";
    
    public static String RAID = "mktRaid";
    public static String RAID_NON_MARKET = "mktRaidNonMarket";
    //public static String RAID_SURPRISE = "mktRaidSurprise";
    //public static String RAID_RARE = "mktRaidRare";
    public static String RAID_VALUABLE = "mktRaidValuable";
    public static String RAID_DISRUPT = "mktRaidDisrupt";
    public static String RAID_GO_BACK = "mktRaidGoBack";
    public static String RAID_CONFIRM_CONTINUE = "mktRaidConfirmContinue";
    
    public static String RAID_CONFIRM = "mktRaidConfirm";
    public static String RAID_CONFIRM_STORY = "mktRaidConfirmStory";
    public static String RAID_NEVER_MIND = "mktRaidNeverMind";
    public static String RAID_RESULT = "mktRaidResult";
    
    public static String INVADE = "mktInvade";
    public static String GO_BACK = "mktGoBack";
    
    public static String BOMBARD = "mktBombard";
    public static String BOMBARD_TACTICAL = "mktBombardTactical";
    public static String BOMBARD_SATURATION = "mktBombardSaturation";
    public static String BOMBARD_CONFIRM = "mktBombardConfirm";
    public static String BOMBARD_NEVERMIND = "mktBombardNeverMind";
    public static String BOMBARD_RESULT = "mktBombardResult";
    
    public static String DEBT_RESULT_CONTINUE = "marketCmd_checkDebtContinue";
    
    
    
    
    public static float DISRUPTION_THRESHOLD = 0.25f;
    public static float VALUABLES_THRESHOLD = 0.05f;
    
    protected CampaignFleetAPI playerFleet;
    protected SectorEntityToken entity;
    protected FactionAPI playerFaction;
    protected FactionAPI entityFaction;
    protected TextPanelAPI text;
    protected OptionPanelAPI options;
    protected CargoAPI playerCargo;
    protected MemoryAPI memory;
    protected MarketAPI market;
    protected InteractionDialogAPI dialog;
    protected Map<String, MemoryAPI> memoryMap;
    protected FactionAPI faction;
 
    protected TempData temp = new TempData();
    
    public MarketCMD() {
        //DebugFlags.MARKET_HOSTILITIES_DEBUG = false;
    }
    
    protected void clearTemp() {
        if (temp != null) {
            //temp.isSurpriseRaid = false;
            temp.raidType = null;
            temp.bombardType = null;
            temp.raidLoot = null;
            temp.target = null;
            temp.willBecomeHostile.clear();
            temp.bombardmentTargets.clear();
            temp.objectives.clear();
            temp.contText = null;
            temp.raidGoBackTrigger = null;
            temp.raidContinueTrigger = null;
            //temp.canFail = false;
            //temp.failProb = 0f;
        }
    }
    
    public MarketCMD(SectorEntityToken entity) {
        init(entity);
    }
    
    protected void init(SectorEntityToken entity) {
        
        memory = entity.getMemoryWithoutUpdate();
        this.entity = entity;
        playerFleet = Global.getSector().getPlayerFleet();
        playerCargo = playerFleet.getCargo();
        
        playerFaction = Global.getSector().getPlayerFaction();
        entityFaction = entity.getFaction();
        
        faction = entity.getFaction();
        
        market = entity.getMarket();
        
        //DebugFlags.MARKET_HOSTILITIES_DEBUG = false;
        //market.getMemoryWithoutUpdate().set(MemFlags.MEMORY_KEY_PLAYER_HOSTILE_ACTIVITY_NEAR_MARKET, true, 0.1f);
        
        String key = "$MarketCMD_temp";
        MemoryAPI mem = null;
        if (market != null) {
            mem = market.getMemoryWithoutUpdate();
        } else {
            mem = entity.getMemoryWithoutUpdate();
        }
        if (mem.contains(key)) {
            temp = (TempData) mem.get(key);
        } else {
            mem.set(key, temp, 0f);
        }
    }
 
    public boolean execute(String ruleId, InteractionDialogAPI dialog, List<Token> params, Map<String, MemoryAPI> memoryMap) {
        this.dialog = dialog;
        this.memoryMap = memoryMap;
        
        String command = params.get(0).getString(memoryMap);
        if (command == null) return false;
        
        entity = dialog.getInteractionTarget();
        init(entity);
        
        memory = getEntityMemory(memoryMap);
        
        text = dialog.getTextPanel();
        options = dialog.getOptionPanel();
        
        if (command.equals("showDefenses")) {
            clearTemp();
            //new ShowDefaultVisual().execute(null, dialog, Misc.tokenize(""), memoryMap);
            showDefenses(true);
        } else if (command.equals("goBackToDefenses")) {
            if (temp.nonMarket) {
                String trigger = temp.raidGoBackTrigger;
                if (trigger == null || trigger.isEmpty()) trigger = "PopulateOptions";
                clearTemp();
                FireAll.fire(null, dialog, memoryMap, trigger);
                return true;
            }
            clearTemp();
            //new ShowDefaultVisual().execute(null, dialog, Misc.tokenize(""), memoryMap);
            showDefenses(true);
            //dialog.getVisualPanel().finishFadeFast();
        } else if (command.equals("engage")) {
            engage();
        } else if (command.equals("raidMenu")) {
//          boolean surprise = "mktRaidSurprise".equals(memory.get("$option"));
//          temp.isSurpriseRaid = surprise;
            raidMenu();
//      } else if (command.equals("raidRare")) {
//          raidRare();
        } else if (command.equals("raidNonMarket")) {
            raidNonMarket();
        } else if (command.equals("raidValuable")) {
            raidValuable();
        } else if (command.equals("raidDisrupt")) {
            raidDisrupt();
        } else if (command.equals("raidConfirm")) {
            raidConfirm(false);
        } else if (command.equals("raidConfirmContinue")) {
            raidConfirmContinue();
        } else if (command.equals("raidNeverMind")) {
            raidNeverMind();
        } else if (command.equals("addContinueToRaidResultOption")) {
            addContinueOption(temp.contText);
        } else if (command.equals("raidResult")) {
            raidResult();
        } else if (command.equals("bombardMenu")) {
            bombardMenu();
        } else if (command.equals("bombardTactical")) {
            bombardTactical();
        } else if (command.equals("bombardSaturation")) {
            bombardSaturation();
        } else if (command.equals("bombardConfirm")) {
            bombardConfirm();
        } else if (command.equals("bombardNeverMind")) {
            bombardNeverMind();
        } else if (command.equals("bombardResult")) {
            bombardResult();
        } else if (command.equals("checkDebtEffect")) {
            return checkDebtEffect();
        } else if (command.equals("applyDebtEffect")) {
            applyDebtEffect();
        } else if (command.equals("checkMercsLeaving")) {
            return checkMercsLeaving();
        } else if (command.equals("convinceMercToStay")) {
            convinceMercToStay();
        } else if (command.equals("mercLeaves")) {
            mercLeaves();
        } else if (command.equals("assistVolturnInsurgents"))
        {
            MarketAPI volturn = Global.getSector().getEconomy().getMarket("volturn");
            RecentUnrest.get(volturn).add(2, "The Luddic insurgency acquired unusually heavy weaponry somehow");
        }
        
        return true;
    }
 
    protected void showDefenses(boolean withText) {
        CampaignFleetAPI primary = getInteractionTargetForFIDPI();
        CampaignFleetAPI station = getStationFleet();
        
        boolean hasNonStation = false;
        boolean hasOtherButInsignificant = true;
        boolean hasStation = station != null;
        boolean otherWantsToFight = false;
        BattleAPI b = null;
        FleetEncounterContext context = null;
        FleetInteractionDialogPluginImpl plugin = null;
        
        boolean ongoingBattle = false;
        
        boolean playerOnDefenderSide = false;
        boolean playerCanNotJoin = false;
 
        String stationType = "station";
        if (station != null) {
            FleetMemberAPI flagship = station.getFlagship();
            if (flagship != null && flagship.getVariant() != null) {
                String name = flagship.getVariant().getDesignation().toLowerCase();
                stationType = name;
            }
        }
        
        StationState state = getStationState();
        
        if (market != null) {
            Global.getSector().getEconomy().tripleStep();
        }
        
        if (primary == null) {
            if (state == StationState.NONE) {
                text.addPara("The colony has no orbital station or nearby fleets to defend it.");
            } else {
                printStationState();
                text.addPara("There are no nearby fleets to defend the colony.");
            }
        } else {
            ongoingBattle = primary.getBattle() != null;
 
            CampaignFleetAPI pluginFleet = primary;
            if (ongoingBattle) {
                BattleSide playerSide = primary.getBattle().pickSide(playerFleet);
                CampaignFleetAPI other = primary.getBattle().getPrimary(primary.getBattle().getOtherSide(playerSide));
                if (other != null) {
                    pluginFleet = other;
                }
            }
            
            FIDConfig params = new FIDConfig();
            params.justShowFleets = true;
            params.showPullInText = withText;
            plugin = new FleetInteractionDialogPluginImpl(params);
            //dialog.setInteractionTarget(primary);
            dialog.setInteractionTarget(pluginFleet);
            plugin.init(dialog);
//          if (ongoingBattle) {
//              plugin.setPlayerFleet(primary.getBattle().getPlayerCombined());
//          }
            dialog.setInteractionTarget(entity);
            
            
            context = (FleetEncounterContext)plugin.getContext();
            b = context.getBattle();
            
            BattleSide playerSide = b.pickSide(playerFleet);
            if (playerSide != BattleSide.NO_JOIN) {
                if (b.getOtherSideCombined(playerSide).isEmpty()) {
                    playerSide = BattleSide.NO_JOIN;
                }
            }
            playerCanNotJoin = playerSide == BattleSide.NO_JOIN;
            if (!playerCanNotJoin) {
                playerOnDefenderSide = b.getSide(playerSide) == b.getSideFor(primary);
            }
            if (!ongoingBattle) {
                playerOnDefenderSide = false;
            }
 
            boolean otherHasStation = false;
            if (playerSide != BattleSide.NO_JOIN) {
                //for (CampaignFleetAPI fleet : b.getNonPlayerSide()) {
                if (station != null) {
                    for (CampaignFleetAPI fleet : b.getSideFor(station)) {
                        if (!fleet.isStationMode()) {
                            hasNonStation = true;
                            hasOtherButInsignificant &= Misc.isInsignificant(fleet);
                        }
                    }
                } else {
                    if (b.getNonPlayerSide() != null) {
                        for (CampaignFleetAPI fleet : b.getNonPlayerSide()) {
                            if (!fleet.isStationMode()) {
                                hasNonStation = true;
                                hasOtherButInsignificant &= Misc.isInsignificant(fleet);
                            }
                        }
                    } else {
                        hasNonStation = true;
                    }
                }
                
                for (CampaignFleetAPI fleet : b.getOtherSide(playerSide)) {
                    if (!fleet.isStationMode()) {
                        //hasNonStation = true;
                    } else {
                        otherHasStation = true;
                    }
                }
            }
            
            if (!hasNonStation) hasOtherButInsignificant = false;
            
            //otherWantsToFight = hasStation || plugin.otherFleetWantsToFight(true);
            
            // inaccurate because it doesn't include the station in the "wants to fight" calculation, but, this is tricky
            // and I don't want to break it right now
            otherWantsToFight = otherHasStation || plugin.otherFleetWantsToFight(true);
            
            if (withText) {
                if (hasStation) {
                    String name = "An orbital station";
                    if (station != null) {
                        FleetMemberAPI flagship = station.getFlagship();
                        if (flagship != null) {
                            name = flagship.getVariant().getDesignation().toLowerCase();
                            stationType = name;
                            name = Misc.ucFirst(station.getFaction().getPersonNamePrefixAOrAn()) + " " + 
                                    station.getFaction().getPersonNamePrefix() + " " + name;
                        }
                    }
                    text.addPara(name + " dominates the orbit and prevents any " +
                                 "hostile action, aside from a quick raid, unless it is dealt with.");
                    
                    
                    if (hasNonStation) {
                        if (ongoingBattle) {
                            text.addPara("There are defending ships present, but they are currently involved in a battle, "
                                    + "and you could take advantage of the distraction to launch a raid.");
                        } else {
                            if (hasOtherButInsignificant) {
                                text.addPara("Defending ships are present, but not in sufficient strength " +
                                         "to want to give battle or prevent any hostile action you might take.");
                            } else {
                                text.addPara("The defending ships present are, with the support of the station, sufficient to prevent " +
                                     "raiding as well.");
                            }
                        }
                    }
                } else if (hasNonStation && otherWantsToFight) {
                    printStationState();
                    text.addPara("Defending ships are present in sufficient strength to prevent any hostile action " +
                    "until they are dealt with.");
                } else if (hasNonStation && !otherWantsToFight) {
                    printStationState();
                    text.addPara("Defending ships are present, but not in sufficient strength " +
                                 "to want to give battle or prevent any hostile action you might take.");
                }
                
                plugin.printOngoingBattleInfo();
            }
        }
 
        if (!hasNonStation) hasOtherButInsignificant = false;
        
        options.clearOptions();
        
        String engageText = "Engage the defenders";
        
        if (playerCanNotJoin) {
            engageText = "Engage the defenders";
        } else if (playerOnDefenderSide) {
            if (hasStation && hasNonStation) {
                engageText = "Aid the " + stationType + " and its defenders";
            } else if (hasStation) {
                engageText = "Aid the " + stationType + "";
            } else {
                engageText = "Aid the defenders";
            }
        } else {
            if (ongoingBattle) {
                engageText = "Aid the attacking forces";
            } else {
                if (hasStation && hasNonStation) {
                    engageText = "Engage the " + stationType + " and its defenders";
                } else if (hasStation) {
                    engageText = "Engage the " + stationType + "";
                } else {
                    engageText = "Engage the defenders";
                }
            }
        }
        
        
        options.addOption(engageText, ENGAGE);
        
        temp.secret = false;
        temp.canRaid = ongoingBattle || hasOtherButInsignificant || (hasNonStation && !otherWantsToFight) || !hasNonStation;
        temp.canBombard = (hasOtherButInsignificant || (hasNonStation && !otherWantsToFight) || !hasNonStation) && !hasStation;
        //temp.canSurpriseRaid = Misc.getDaysSinceLastRaided(market) < SURPRISE_RAID_TIMEOUT;
        
        boolean couldRaidIfNotDebug = temp.canRaid;
        if (DebugFlags.MARKET_HOSTILITIES_DEBUG) {
            if (!temp.canRaid || !temp.canBombard) {
                text.addPara("(DEBUG mode: can raid and bombard anyway)");
            }
            temp.canRaid = true;
            temp.canBombard = true;
            //temp.canSurpriseRaid = true;
        }
            
//      options.addOption("Launch a raid against the colony", RAID);
//      options.addOption("Consider an orbital bombardment", BOMBARD);
//      options.addOption("Launch a surprise raid against " + market.getName(), RAID_SURPRISE);
        options.addOption("Launch a raid against " + market.getName() + "", RAID);
        //dialog.setOptionColor(RAID_SURPRISE, Misc.getStoryOptionColor());
        options.addOption("Consider an orbital bombardment of " + market.getName() + "", BOMBARD);
        
        if (!temp.canRaid) {
            options.setEnabled(RAID, false);
            options.setTooltip(RAID, "The presence of enemy fleets that are willing to offer battle makes a raid impossible.");
        } 
        
//      if (!temp.canSurpriseRaid) {
//          options.setEnabled(RAID_SURPRISE, false);
//          options.setTooltip(RAID_SURPRISE, "This colony was raided within the last cycle and its ground defenses are on high alert, making a surprise raid impossible.");
//      }
        
        if (!temp.canBombard) {
            options.setEnabled(BOMBARD, false);
            options.setTooltip(BOMBARD, "All defenses must be defeated to make a bombardment possible.");
        }
        
        
        //DEBUG = false;
        if (temp.canRaid && getRaidCooldown() > 0) {// && couldRaidIfNotDebug) {
            if (!DebugFlags.MARKET_HOSTILITIES_DEBUG) {
                options.setEnabled(RAID, false);
                text.addPara("Your forces will be able to organize another raid within a day or so.");
                temp.canRaid = false;
            } else {
                text.addPara("Your forces will be able to organize another raid within a day or so.");
                text.addPara("(DEBUG mode: can do it anyway)");
            }
            //options.setTooltip(RAID, "Need more time to organize another raid.");
        }
        
        //options.addOption("Launch a raid of the colony", RAID);
        
        
        if (context != null && otherWantsToFight && !playerCanNotJoin) {
            boolean knows = context.getBattle() != null && context.getBattle().getNonPlayerSide() != null &&
                            context.getBattle().knowsWhoPlayerIs(context.getBattle().getNonPlayerSide());
            boolean lowImpact = context.isLowRepImpact();
            FactionAPI nonHostile = plugin.getNonHostileOtherFaction();
            //if (!playerFleet.getFaction().isHostileTo(otherFleet.getFaction()) && knows && !context.isEngagedInHostilities()) {
            if (nonHostile != null && knows && !lowImpact && !context.isEngagedInHostilities()) {
                options.addOptionConfirmation(ENGAGE,
                        "The " + nonHostile.getDisplayNameLong() + 
                        " " + nonHostile.getDisplayNameIsOrAre() + 
                        " not currently hostile, and you have been positively identified. " +
                        "Are you sure you want to engage in open hostilities?", "Yes", "Never mind");
            }
        } else if (context == null || playerCanNotJoin || !otherWantsToFight) {
            options.setEnabled(ENGAGE, false);
            if (!otherWantsToFight) {
                if (ongoingBattle && playerOnDefenderSide && !otherWantsToFight) {
                    options.setTooltip(ENGAGE, "The attackers are in disarray and not currently attempting to engage the station.");
                } else {
                    if (playerCanNotJoin) {
                        options.setTooltip(ENGAGE, "You're unable to join this battle.");
                    } else if (primary == null) {
                        options.setTooltip(ENGAGE, "There are no defenders to engage.");
                    } else {
                        options.setTooltip(ENGAGE, "The defenders are refusing to give battle to defend the colony.");
                    }
                }
            }
        }
        
        options.addOption("Go back", GO_BACK);
        options.setShortcut(GO_BACK, Keyboard.KEY_ESCAPE, false, false, false, true);
        
        
        if (plugin != null) {
            plugin.cleanUpBattle();
        }
        
    }
    
    public static float getRaidStr(CampaignFleetAPI fleet) {
        float attackerStr = fleet.getCargo().getMaxPersonnel() * 0.25f;
        float support = Misc.getFleetwideTotalMod(fleet, Stats.FLEET_GROUND_SUPPORT, 0f);
        attackerStr += Math.min(support, attackerStr);
        
        StatBonus stat = fleet.getStats().getDynamic().getMod(Stats.PLANETARY_OPERATIONS_MOD);
        attackerStr = stat.computeEffective(attackerStr);
        
        return attackerStr;
    }
    
    public static float MARINES_IN_MARKET_CARGO_DEFENSE_BONUS = 1f;
    public static float getDefenderStr(MarketAPI market) {
        return getDefenderStr(market, false);
    }
    public static float getDefenderStr(MarketAPI market, boolean forBombard) {
        StatBonus stat = market.getStats().getDynamic().getMod(Stats.GROUND_DEFENSES_MOD);
        float defenderStr = (int) Math.round(stat.computeEffective(0f));
        float added = getDefenderIncreaseValue(market);
        defenderStr += added;
        
        if (market.isPlayerOwned() && !forBombard) {
            float marineDefenseValueMult = MARINES_IN_MARKET_CARGO_DEFENSE_BONUS;
            CargoAPI cargo = Misc.getStorageCargo(market);
            if (cargo != null) {
                defenderStr += cargo.getMarines() * marineDefenseValueMult;
            }
            cargo = Misc.getLocalResourcesCargo(market);
            if (cargo != null) {
                defenderStr += cargo.getMarines() * marineDefenseValueMult;
            }
        }
        
        return defenderStr;
    }
    
    public static float getRaidEffectiveness(MarketAPI market, CampaignFleetAPI fleet) {
        return getRaidEffectiveness(market, getRaidStr(fleet));
    }
    public static float getRaidEffectiveness(MarketAPI market, float attackerStr) {
        float defenderStr = getDefenderStr(market);
        return attackerStr / Math.max(1f, (attackerStr + defenderStr));
    }
 
    public static int getMarinesFor(MarketAPI market, int tokens) {
        float defenderStr = getDefenderStr(market);
        return getMarinesFor((int)defenderStr, tokens);
    }
    public static int getMarinesFor(int defenderStrength, int tokens) {
//      mult = as / (as + ds);
//      tokens = mult / re_per
//
//      t * re_per = as / (as + ds)
//      t * re_per * (as + ds) = as;
//      t * re_per * as + t * re_per * ds = as;
//      t * re_per * ds = as * (1 - t * re_per)
//      as = t * re_per * ds / (1 - t * re_per)
        
        
        int marines = (int) Math.round((float) tokens * RE_PER_MARINE_TOKEN * 
                            (float) defenderStrength / (1f - (float) tokens * RE_PER_MARINE_TOKEN));
        
        return marines;
    }
    public static int getDisruptDaysPerToken(MarketAPI market, Industry industry) {
        DisruptIndustryRaidObjectivePluginImpl obj = new DisruptIndustryRaidObjectivePluginImpl(market, industry);
        return (int) Math.round(obj.getBaseDisruptDuration(1));
    }
    
    
    protected void raidNonMarket() {
        float width = 350;
        float opad = 10f;
        float small = 5f;
        
        Color h = Misc.getHighlightColor();
        
        temp.nonMarket = true;
        
        float difficulty = memory.getFloat("$raidDifficulty");
        temp.raidGoBackTrigger = memory.getString("$raidGoBackTrigger");
        temp.raidContinueTrigger = memory.getString("$raidContinueTrigger");
        
        dialog.getVisualPanel().showImagePortion("illustrations", "raid_prepare", 640, 400, 0, 0, 480, 300);
        
        float marines = playerFleet.getCargo().getMarines();
        float support = Misc.getFleetwideTotalMod(playerFleet, Stats.FLEET_GROUND_SUPPORT, 0f);
        if (support > marines) support = marines;
        
        StatBonus attackerBase = new StatBonus(); 
        StatBonus defenderBase = new StatBonus();
        
        //defenderBase.modifyFlatAlways("base", baseDef, "Base value for a size " + market.getSize() + " colony");
        
        attackerBase.modifyFlatAlways("core_marines", marines, "Marines on board");
        attackerBase.modifyFlatAlways("core_support", support, "Fleet capability for ground support");
        
        StatBonus attacker = playerFleet.getStats().getDynamic().getMod(Stats.PLANETARY_OPERATIONS_MOD);
        StatBonus defender = new StatBonus();
        if (market != null && difficulty <= 0) defender = market.getStats().getDynamic().getMod(Stats.GROUND_DEFENSES_MOD);
        
        defender.modifyFlat("difficulty", difficulty, "Expected resistance");
        
        String surpriseKey = "core_surprise";
//      if (temp.isSurpriseRaid) {
//          //defender.modifyMult(surpriseKey, 0.1f, "Surprise raid");
//          attacker.modifyMult(surpriseKey, SURPRISE_RAID_STRENGTH_MULT, "Surprise raid");
//      }
        
        String increasedDefensesKey = "core_addedDefStr";
        float added = 0;
        if (market != null) added = getDefenderIncreaseValue(market);
        if (added > 0) {
            defender.modifyFlat(increasedDefensesKey, added, "Increased defender preparedness");
        }
        
        float attackerStr = (int) Math.round(attacker.computeEffective(attackerBase.computeEffective(0f)));
        float defenderStr = (int) Math.round(defender.computeEffective(defenderBase.computeEffective(0f)));
        
        temp.attackerStr = attackerStr;
        temp.defenderStr = defenderStr;
        
        TooltipMakerAPI info = text.beginTooltip();
        
        info.setParaSmallInsignia();
        
        String has = faction.getDisplayNameHasOrHave();
        String is = faction.getDisplayNameIsOrAre();
        boolean hostile = faction.isHostileTo(Factions.PLAYER);
        boolean tOn = playerFleet.isTransponderOn();
        float initPad = 0f;
        if (!hostile && !faction.isNeutralFaction()) {
            if (tOn) {
                info.addPara(Misc.ucFirst(faction.getDisplayNameWithArticle()) + " " + is + 
                        " not currently hostile. Your fleet's transponder is on, and carrying out a raid " +
                        "will result in open hostilities.",
                        initPad, faction.getBaseUIColor(), faction.getDisplayNameWithArticleWithoutArticle());
            } else {
                info.addPara(Misc.ucFirst(faction.getDisplayNameWithArticle()) + " " + is + 
                        " not currently hostile. Your fleet's transponder is off, and carrying out a raid " +
                        "will only result in a minor penalty to your standing.",
                        initPad, faction.getBaseUIColor(), faction.getDisplayNameWithArticleWithoutArticle());
            }
            initPad = opad;
        }
        
        float sep = small;
        sep = 3f;
        info.addPara("Raid strength: %s", initPad, h, "" + (int)attackerStr);
        info.addStatModGrid(width, 50, opad, small, attackerBase, true, statPrinter(false));
        if (!attacker.isUnmodified()) {
            info.addStatModGrid(width, 50, opad, sep, attacker, true, statPrinter(true));
        }
        
        
        info.addPara("Operation difficulty: %s", opad, h, "" + (int)defenderStr);
        //info.addStatModGrid(width, 50, opad, small, defenderBase, true, statPrinter());
        //if (!defender.isUnmodified()) {
        info.addStatModGrid(width, 50, opad, small, defender, true, statPrinter(true));
        //}
        
        defender.unmodifyFlat(increasedDefensesKey);
        defender.unmodifyMult(surpriseKey);
        attacker.unmodifyMult(surpriseKey);
        
        text.addTooltip();
        
        boolean hasForces = true;
        temp.raidMult = attackerStr / Math.max(1f, (attackerStr + defenderStr));
        temp.raidMult = Math.round(temp.raidMult * 100f) / 100f;
        
        {
            Color eColor = h;
            if (temp.raidMult < DISRUPTION_THRESHOLD && temp.raidMult < VALUABLES_THRESHOLD) {
                eColor = Misc.getNegativeHighlightColor();
            }
            text.addPara("Projected raid effectiveness: %s",
                    eColor,
                    "" + (int)(temp.raidMult * 100f) + "%");
            //"" + (int)Math.round(temp.raidMult * 100f) + "%");
            if (temp.raidMult < VALUABLES_THRESHOLD) {
                text.addPara("You do not have the forces to carry out an effective raid.");
                hasForces = false;
            }
        }
        
        options.clearOptions();
        
        options.addOption("Designate raid objectives", RAID_VALUABLE);
        
        if (!hasForces) {
            options.setEnabled(RAID_VALUABLE, false);
        }
        
        options.addOption("Go back", RAID_GO_BACK);
        options.setShortcut(RAID_GO_BACK, Keyboard.KEY_ESCAPE, false, false, false, true);
    }
    
    
//  protected void raidRare() {
//      
//  }
    
    protected void raidMenu() {
        float width = 350;
        float opad = 10f;
        float small = 5f;
        
//      if (true) {
//          Global.getSector().getCampaignUI().showCoreUITab(CoreUITabId.CARGO);
//          return;
//      }
        
        Color h = Misc.getHighlightColor();
        
        temp.nonMarket = false;
        
//      dialog.getVisualPanel().showPlanetInfo(market.getPrimaryEntity());
//      dialog.getVisualPanel().finishFadeFast();
        dialog.getVisualPanel().showImagePortion("illustrations", "raid_prepare", 640, 400, 0, 0, 480, 300);
 
        float marines = playerFleet.getCargo().getMarines();
        float support = Misc.getFleetwideTotalMod(playerFleet, Stats.FLEET_GROUND_SUPPORT, 0f);
        if (support > marines) support = marines;
        
        StatBonus attackerBase = new StatBonus(); 
        StatBonus defenderBase = new StatBonus(); 
        
        //defenderBase.modifyFlatAlways("base", baseDef, "Base value for a size " + market.getSize() + " colony");
        
        attackerBase.modifyFlatAlways("core_marines", marines, "Marines on board");
        attackerBase.modifyFlatAlways("core_support", support, "Fleet capability for ground support");
        
        StatBonus attacker = playerFleet.getStats().getDynamic().getMod(Stats.PLANETARY_OPERATIONS_MOD);
        StatBonus defender = market.getStats().getDynamic().getMod(Stats.GROUND_DEFENSES_MOD);
        
        String surpriseKey = "core_surprise";
//      if (temp.isSurpriseRaid) {
//          //defender.modifyMult(surpriseKey, 0.1f, "Surprise raid");
//          attacker.modifyMult(surpriseKey, SURPRISE_RAID_STRENGTH_MULT, "Surprise raid");
//      }
        
        String increasedDefensesKey = "core_addedDefStr";
        float added = getDefenderIncreaseValue(market);
        if (added > 0) {
            defender.modifyFlat(increasedDefensesKey, added, "Increased defender preparedness");
        }
        
        float attackerStr = (int) Math.round(attacker.computeEffective(attackerBase.computeEffective(0f)));
        float defenderStr = (int) Math.round(defender.computeEffective(defenderBase.computeEffective(0f)));
        
        temp.attackerStr = attackerStr;
        temp.defenderStr = defenderStr;
        
        TooltipMakerAPI info = text.beginTooltip();
        
        info.setParaSmallInsignia();
        
        String has = faction.getDisplayNameHasOrHave();
        String is = faction.getDisplayNameIsOrAre();
        boolean hostile = faction.isHostileTo(Factions.PLAYER);
        boolean tOn = playerFleet.isTransponderOn();
        float initPad = 0f;
        if (!hostile) {
            if (tOn) {
                info.addPara(Misc.ucFirst(faction.getDisplayNameWithArticle()) + " " + is + 
                        " not currently hostile. Your fleet's transponder is on, and carrying out a raid " +
                        "will result in open hostilities.",
                        initPad, faction.getBaseUIColor(), faction.getDisplayNameWithArticleWithoutArticle());
            } else {
                info.addPara(Misc.ucFirst(faction.getDisplayNameWithArticle()) + " " + is + 
                        " not currently hostile. Your fleet's transponder is off, and carrying out a raid " +
                        "will only result in a minor penalty to your standing.",
                        initPad, faction.getBaseUIColor(), faction.getDisplayNameWithArticleWithoutArticle());
            }
            initPad = opad;
        }
        
        float sep = small;
        sep = 3f;
        info.addPara("Raid strength: %s", initPad, h, "" + (int)attackerStr);
        info.addStatModGrid(width, 50, opad, small, attackerBase, true, statPrinter(false));
        if (!attacker.isUnmodified()) {
            info.addStatModGrid(width, 50, opad, sep, attacker, true, statPrinter(true));
        }
        
        
        info.addPara("Ground defense strength: %s", opad, h, "" + (int)defenderStr);
        //info.addStatModGrid(width, 50, opad, small, defenderBase, true, statPrinter());
        //if (!defender.isUnmodified()) {
            info.addStatModGrid(width, 50, opad, small, defender, true, statPrinter(true));
        //}
            
        defender.unmodifyFlat(increasedDefensesKey);
        defender.unmodifyMult(surpriseKey);
        attacker.unmodifyMult(surpriseKey);
        
        text.addTooltip();
 
        boolean hasForces = true;
        boolean canDisrupt = true;
        temp.raidMult = attackerStr / Math.max(1f, (attackerStr + defenderStr));
        temp.raidMult = Math.round(temp.raidMult * 100f) / 100f;
        //temp.raidMult = 1f;
        
        
        
        
        {
            //temp.failProb = 0f;
            Color eColor = h;
            if (temp.raidMult < DISRUPTION_THRESHOLD && temp.raidMult < VALUABLES_THRESHOLD) {
                eColor = Misc.getNegativeHighlightColor();
            }
            if (temp.raidMult < DISRUPTION_THRESHOLD) {
                //eColor = Misc.getNegativeHighlightColor();
                canDisrupt = false;
                //temp.canFail = true;
            } else if (temp.raidMult >= 0.7f) {
                //eColor = Misc.getPositiveHighlightColor();
            }
//          text.addPara("Projected raid effectiveness: %s. " +
//                  "This will determine the outcome of the raid, " +
//                  "as well as the casualties suffered by your forces, if any.",
//                  eColor,
//                  "" + (int)Math.round(temp.raidMult * 100f) + "%");
            text.addPara("Projected raid effectiveness: %s",
                    eColor,
                    "" + (int)(temp.raidMult * 100f) + "%");
                    //"" + (int)Math.round(temp.raidMult * 100f) + "%");
            if (!canDisrupt) {
                text.addPara("The ground defenses are too strong for your forces to be able to cause long-term disruption.");
            }
            if (temp.raidMult < VALUABLES_THRESHOLD) {
                text.addPara("You do not have the forces to carry out an effective raid to acquire valuables or achieve other objectives.");
                hasForces = false;
            }
//          if (canDisrupt) {
//          } else {
//              text.addPara("Projected raid effectiveness: %s. " +
//                      "This will determine the outcome of the raid, " +
//                      "as well as the casualties suffered by your forces, if any.",
//                      eColor,
//                      "" + (int)Math.round(temp.raidMult * 100f) + "%");
//          }
        }
        
        if (DebugFlags.MARKET_HOSTILITIES_DEBUG) {
            canDisrupt = true;
        }
        
        options.clearOptions();
        
        //options.addOption("Try to acquire rare items, such as blueprints", RAID_RARE);
        //options.addOption("Try to acquire valuables, such as commodities, blueprints, and other items", RAID_VALUABLE);
        options.addOption("Try to acquire valuables, such as commodities or blueprints, or achieve other objectives", RAID_VALUABLE);
        options.addOption("Disrupt the operations of a specific industry or facility", RAID_DISRUPT);
        
        if (!hasForces) {
            options.setEnabled(RAID_VALUABLE, false);
            //options.setEnabled(RAID_RARE, false);
        }
        
        if (!hasForces || !canDisrupt) {
            options.setEnabled(RAID_DISRUPT, false);
            if (!canDisrupt) {
                String pct = "" + (int)Math.round(DISRUPTION_THRESHOLD * 100f) + "%";
                options.setTooltip(RAID_DISRUPT, "Requires at least " + pct + " raid effectiveness.");
                options.setTooltipHighlights(RAID_DISRUPT, pct);
                options.setTooltipHighlightColors(RAID_DISRUPT, h);
            }
        }
    
        options.addOption("Go back", RAID_GO_BACK);
        options.setShortcut(RAID_GO_BACK, Keyboard.KEY_ESCAPE, false, false, false, true);
    }
    
//  protected void raidRare() {
//      
//  }
    
    protected void raidValuable() {
        temp.raidType = RaidType.VALUABLE;
        
        List<GroundRaidObjectivePlugin> obj = new ArrayList<GroundRaidObjectivePlugin>();
        
        // See: StandardGroundRaidObjectivesCreator; it creates the standard objectives with priority 0 below
        final RaidType useType = !temp.nonMarket ? temp.raidType : RaidType.CUSTOM_ONLY;
        //if (temp.nonMarket) useType = RaidType.CUSTOM_ONLY;
        for (int i = 0; i < 10; i++) {
            ListenerUtil.modifyRaidObjectives(market, entity, obj, useType, getNumMarineTokens(), i);
        }
        
        if (obj.isEmpty()) {
            text.addPara("After careful consideration, there do not appear to be any targets " +
                         "likely to yield anything of value.");
            addNeverMindOption();
            return;
        }
        
        
        dialog.showGroundRaidTargetPicker("Select raid objectives", "Select", market, obj, 
                new GroundRaidTargetPickerDelegate() {
            public void pickedGroundRaidTargets(List<GroundRaidObjectivePlugin> data) {
                float value = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    value += curr.getProjectedCreditsValue();
                }
                Color h = Misc.getHighlightColor();
                List<String> names = new ArrayList<String>();
                for (GroundRaidObjectivePlugin curr : data) {
                    names.add(curr.getNameOverride() != null ? curr.getNameOverride() : curr.getName());
                }
                String list = Misc.getAndJoined(names);
                String item = "objective";
                if (names.size() > 1) {
                    item = "objectives";
                }
                
                String isOrAre = "are";
                String marinesStr = "marines";
                if (playerCargo.getMarines() == 1) {
                    isOrAre = "is";
                    marinesStr = "marine";
                }
                //float losses = getProjectedMarineLossesFloat();
                LabelAPI label = text.addPara("Your marine commander submits a plan for your approval. Losses during this " +
                        "operation are projected to be %s. There " + isOrAre + " a total of %s " +
                        marinesStr + " in your fleet.", 
                        getMarineLossesColor(data), getProjectedMarineLosses(data).toLowerCase(), 
                        Misc.getWithDGS(playerCargo.getMarines()));
                label.setHighlightColors(getMarineLossesColor(data), Misc.getHighlightColor());
                text.addPara(Misc.ucFirst(item) + " targeted: " + list + ".", h,
                        names.toArray(new String[0]));
                if (value > 0) {
                    text.addPara("The estimated value of the items obtained is projected to be around %s.",
                            h, Misc.getDGSCredits(value));
                }
 
//              text.addPara("The marines are ready to go, awaiting your final confirmation. There are a total of %s " +
//                      "marines in your fleet.", Misc.getHighlightColor(), Misc.getWithDGS(playerCargo.getMarines()));
                text.addPara("The marines are ready to go, awaiting your final confirmation.");
                temp.objectives = data;
                addConfirmOptions();
            }
            
            public boolean isDisruptIndustryMode() {
                return false;
            }
            
            public boolean isCustomOnlyMode() {
                return useType == RaidType.CUSTOM_ONLY;
            }
            
            public void cancelledGroundRaidTargetPicking() {
                
            }
            
            public int getCargoSpaceNeeded(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getCargoSpaceNeeded();
                }
                return (int) total;
            }
 
            public int getFuelSpaceNeeded(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getFuelSpaceNeeded();
                }
                return (int) total;
            }
 
            public int getProjectedCreditsValue(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getProjectedCreditsValue();
                }
                return (int) total;
            }
            
            public int getNumMarineTokens() {
                return MarketCMD.this.getNumMarineTokens();
            }
            
            public MutableStat getMarineLossesStat(List<GroundRaidObjectivePlugin> data) {
                return MarketCMD.this.getMarineLossesStat(data);
            }
            
            public String getProjectedMarineLosses(List<GroundRaidObjectivePlugin> data) {
                //return "" + (int) Math.round(getProjectedMarineLossesFloat());
                float marines = playerFleet.getCargo().getMarines();
                float losses = getAverageMarineLosses(data);
                
                float f = losses / Math.max(1f, marines);
                
                for (RaidDangerLevel level : RaidDangerLevel.values()) {
                    float test = level.marineLossesMult + (level.next().marineLossesMult - level.marineLossesMult) * 0.5f;
                    if (level == RaidDangerLevel.NONE) test = RaidDangerLevel.NONE.marineLossesMult;
                    if (test >= f) {
                        return level.lossesName;
                    }
                }
                return RaidDangerLevel.EXTREME.lossesName;
            }
            
            public float getAverageMarineLosses(List<GroundRaidObjectivePlugin> data) {
                return MarketCMD.this.getAverageMarineLosses(data);
            }
        
            public Color getMarineLossesColor(List<GroundRaidObjectivePlugin> data) {
                float marines = playerFleet.getCargo().getMarines();
                float losses = getAverageMarineLosses(data);
                
                    
                float f = losses / Math.max(1f, marines);
                if (f <= 0 && data.isEmpty())  return Misc.getGrayColor();
                
                for (RaidDangerLevel level : RaidDangerLevel.values()) {
                    float test = level.marineLossesMult + (level.next().marineLossesMult - level.marineLossesMult) * 0.5f;
                    if (test >= f) {
                        return level.color;
                    }
                }
                return RaidDangerLevel.EXTREME.color;
            }
            public String getRaidEffectiveness() {
                return "" + (int)(temp.raidMult * 100f) + "%";
            }
        });
    }
    
    protected void addBombardConfirmOptions() {
        options.clearOptions();
        options.addOption("Launch bombardment", BOMBARD_CONFIRM);
        options.addOption("Never mind", BOMBARD_NEVERMIND);
        options.setShortcut(BOMBARD_NEVERMIND, Keyboard.KEY_ESCAPE, false, false, false, true);
        
        List<FactionAPI> nonHostile = new ArrayList<FactionAPI>();
        for (FactionAPI faction : temp.willBecomeHostile) {
            boolean hostile = faction.isHostileTo(Factions.PLAYER);
            if (!hostile) {
                nonHostile.add(faction);
            }
        }
        
        if (nonHostile.size() == 1) {
            FactionAPI faction = nonHostile.get(0);
            options.addOptionConfirmation(BOMBARD_CONFIRM,
                    "The " + faction.getDisplayNameLong() + 
                    " " + faction.getDisplayNameIsOrAre() + 
                    " not currently hostile, and will become hostile if you carry out the bombardment. " +
                    "Are you sure?", "Yes", "Never mind");
        } else if (nonHostile.size() > 1) {
            options.addOptionConfirmation(BOMBARD_CONFIRM,
                    "Multiple factions that are not currently hostile " +
                    "will become hostile if you carry out the bombardment. " +
                    "Are you sure?", "Yes", "Never mind");
        }
    }
    
    protected void raidDisrupt() {
        temp.raidType = RaidType.DISRUPT;
        
        // See: StandardGroundRaidObjectivesCreator; it creates the standard objectives with priority 0 below
        List<GroundRaidObjectivePlugin> obj = new ArrayList<GroundRaidObjectivePlugin>();
        for (int i = 0; i < 10; i++) {
            ListenerUtil.modifyRaidObjectives(market, entity, obj, temp.raidType, getNumMarineTokens(), i);
        }
        
        if (obj.isEmpty()) {
            text.addPara("There are no industries or facilities present that could be disrupted by a raid.");
            addNeverMindOption();
            return;
        }
        
        
        dialog.showGroundRaidTargetPicker("Select raid objectives", "Select", market, obj, 
                new GroundRaidTargetPickerDelegate() {
            public void pickedGroundRaidTargets(List<GroundRaidObjectivePlugin> data) {
                float value = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    value += curr.getProjectedCreditsValue();
                }
                Color h = Misc.getHighlightColor();
                List<String> names = new ArrayList<String>();
                for (GroundRaidObjectivePlugin curr : data) {
                    names.add(curr.getNameOverride() != null ? curr.getNameOverride() : curr.getName());
                }
                String list = Misc.getAndJoined(names);
                String item = "objective";
                if (names.size() > 1) {
                    item = "objectives";
                }
                
                //float losses = getProjectedMarineLossesFloat();
 
                text.addPara("Your marine commander submits a plan for your approval. Losses during this " +
                        "operation are projected to be %s.", 
                        getMarineLossesColor(data), getProjectedMarineLosses(data).toLowerCase());
                text.addPara(Misc.ucFirst(item) + " targeted: " + list + ".", h,
                        names.toArray(new String[0]));
                
                if (value > 0) {
                    text.addPara("The estimated value of the items obtained is projected to be around %s.",
                            h, Misc.getDGSCredits(value));
                }
 
                text.addPara("The marines are ready to go, awaiting your final confirmation. There are a total of %s " +
                        "marines in your fleet.", Misc.getHighlightColor(), Misc.getWithDGS(playerCargo.getMarines()));
                temp.objectives = data;
                addConfirmOptions();
            }
            
            public boolean isDisruptIndustryMode() {
                return true;
            }
            
            public void cancelledGroundRaidTargetPicking() {
                
            }
            
            public int getCargoSpaceNeeded(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getCargoSpaceNeeded();
                }
                return (int) total;
            }
 
            public int getFuelSpaceNeeded(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getFuelSpaceNeeded();
                }
                return (int) total;
            }
 
            public int getProjectedCreditsValue(List<GroundRaidObjectivePlugin> data) {
                float total = 0;
                for (GroundRaidObjectivePlugin curr : data) {
                    total += curr.getProjectedCreditsValue();
                }
                return (int) total;
            }
            
            public int getNumMarineTokens() {
                return MarketCMD.this.getNumMarineTokens();
            }
            
            public MutableStat getMarineLossesStat(List<GroundRaidObjectivePlugin> data) {
                return MarketCMD.this.getMarineLossesStat(data);
            }
            
            public String getProjectedMarineLosses(List<GroundRaidObjectivePlugin> data) {
                //return "" + (int) Math.round(getProjectedMarineLossesFloat());
                float marines = playerFleet.getCargo().getMarines();
                float losses = getAverageMarineLosses(data);
                
                float f = losses / Math.max(1f, marines);
                
                for (RaidDangerLevel level : RaidDangerLevel.values()) {
                    float test = level.marineLossesMult + (level.next().marineLossesMult - level.marineLossesMult) * 0.5f;
                    if (level == RaidDangerLevel.NONE) test = RaidDangerLevel.NONE.marineLossesMult;
                    if (test >= f) {
                        return level.lossesName;
                    }
                }
                return RaidDangerLevel.EXTREME.lossesName;
            }
            
            public float getAverageMarineLosses(List<GroundRaidObjectivePlugin> data) {
                return MarketCMD.this.getAverageMarineLosses(data);
            }
        
            public Color getMarineLossesColor(List<GroundRaidObjectivePlugin> data) {
                float marines = playerFleet.getCargo().getMarines();
                float losses = getAverageMarineLosses(data);
                
                    
                float f = losses / Math.max(1f, marines);
                if (f <= 0)  return Misc.getGrayColor();
                
                for (RaidDangerLevel level : RaidDangerLevel.values()) {
                    float test = level.marineLossesMult + (level.next().marineLossesMult - level.marineLossesMult) * 0.5f;
                    if (test >= f) {
                        return level.color;
                    }
                }
                return RaidDangerLevel.EXTREME.color;
            }
            public String getRaidEffectiveness() {
                return "" + (int)(temp.raidMult * 100f) + "%";
            }
 
            public boolean isCustomOnlyMode() {
                // TODO Auto-generated method stub
                return false;
            }
        });     
        
        
//      dialog.showIndustryPicker("Select raid target", "Select", market, targets, new IndustryPickerListener() {
//          public void pickedIndustry(Industry industry) {
//              raidDisruptIndustryPicked(industry);
//          }
//          public void cancelledIndustryPicking() {
//              
//          }
//      });
    }
    
    protected float computeBaseDisruptDuration(Industry ind) {
        //float dur = getNumMarineTokens() * Global.getSettings().getFloat("raidDisruptDurationPerMarineToken") - ind.getDisruptedDays();
        float dur = getNumMarineTokens() * ind.getSpec().getDisruptDanger().disruptionDays - ind.getDisruptedDays();
        return (int) dur;
    }
    
    public static int getBombardDestroyThreshold() {
        return Global.getSettings().getInt("bombardSaturationDestroySize");
        
    }
    public static int getBombardDisruptDuration() {
        float dur = Global.getSettings().getFloat("bombardDisruptDuration");
        return (int) dur;
    }
    
    protected void raidDisruptIndustryPicked(Industry target) {
        temp.target = target;
        text.addParagraph("Target: " + target.getCurrentName(), Global.getSettings().getColor("buttonText"));
        
        float dur = computeBaseDisruptDuration(target);
        
        Color h = Misc.getHighlightColor();
        
        float already = target.getDisruptedDays();
        if (already > 0) {
            text.addPara(target.getNameForModifier() + " operations are already disrupted, and a raid will have " +
                    "reduced effect.");
        }
        
        text.addPara("Your ground forces commander estimates that given the relative force strengths, " +
                " the raid should disrupt all " + target.getCurrentName() + " operations for at least %s days.",
                h, "" + (int) Misc.getRounded(dur));
        
        text.addPara("Your forces are ready to go, awaiting your final confirmation.");
        
        options.clearOptions();
        
        addConfirmOptions();
    }
    
    
    protected void addNeverMindOption() {
        options.clearOptions();
        options.addOption("Never mind", RAID_NEVER_MIND);
        options.setShortcut(RAID_NEVER_MIND, Keyboard.KEY_ESCAPE, false, false, false, true);
    }
    
    protected void addBombardNeverMindOption() {
        options.clearOptions();
        options.addOption("Never mind", BOMBARD_NEVERMIND);
        options.setShortcut(BOMBARD_NEVERMIND, Keyboard.KEY_ESCAPE, false, false, false, true);
    }
    
    protected void addContinueOption() {
        addContinueOption(null);
    }
    protected void addContinueOption(String text) {
        if (text == null) text = "Continue";
        options.clearOptions();
        options.addOption(text, RAID_RESULT);
    }
    
    
    public static final String DEFENDER_INCREASE_KEY = "$core_defenderIncrease";
    public static float getDefenderIncreaseRaw(MarketAPI market) {
        if (market == null) return 0f;
        float e = market.getMemoryWithoutUpdate().getExpire(DEFENDER_INCREASE_KEY);
        if (e < 0) e = 0;
        return e;
    }
    
    public static void applyDefenderIncreaseFromRaid(MarketAPI market) {
        float e = market.getMemoryWithoutUpdate().getExpire(DEFENDER_INCREASE_KEY);
        if(e < 0) e = 0;
        e += getRaidDefenderIncreasePerRaid();
        float max = getRaidDefenderIncreaseMax();
        if (e > max) e = max;
        
        market.getMemoryWithoutUpdate().set(DEFENDER_INCREASE_KEY, true);
        market.getMemoryWithoutUpdate().expire(DEFENDER_INCREASE_KEY, e);
    }
    
    public static float getDefenderIncreaseValue(MarketAPI market) {
        float e = getDefenderIncreaseRaw(market);
        float f = getRaidDefenderIncreaseFraction();
        float min = getRaidDefenderIncreaseMin();
        
        float base = PopulationAndInfrastructure.getBaseGroundDefenses(market.getSize());
        float incr = Math.max(base * f, min);
        
        float per = getRaidDefenderIncreasePerRaid();
        
        return (int)(incr * e / per);
    }
    
    protected static float getRaidDefenderIncreasePerRaid() {
        return Global.getSettings().getFloat("raidDefenderIncreasePerRaid");
    }
    protected static float getRaidDefenderIncreaseMax() {
        return Global.getSettings().getFloat("raidDefenderIncreaseMax");
    }
    protected static float getRaidDefenderIncreaseFraction() {
        return Global.getSettings().getFloat("raidDefenderIncreaseFraction");
    }
    protected static float getRaidDefenderIncreaseMin() {
        return Global.getSettings().getFloat("raidDefenderIncreaseMin");
    }
    
    
    protected float getRaidCooldownMax() {
        return Global.getSettings().getFloat("raidCooldownDays");
    }
    
    protected void setRaidCooldown(float cooldown) {
        String key = "$raid_cooldown";
        Global.getSector().getMemoryWithoutUpdate().set(key, true, cooldown);
    }
    
    protected float getRaidCooldown() {
        String key = "$raid_cooldown";
        return Global.getSector().getMemoryWithoutUpdate().getExpire(key);
    }
    
    protected Random getRandom() {
        String key = "$raid_random";
        MemoryAPI mem = null;
        SectorEntityToken entity = null;
        if (market != null) {
            mem = market.getMemoryWithoutUpdate();
            entity = market.getPrimaryEntity();
        } else {
            entity = this.entity;
            mem = entity.getMemoryWithoutUpdate();
        }
        Random random = null;
        if (mem.contains(key)) {
            random = (Random) mem.get(key);
        } else {
            if (entity != null) {
                long seed = Misc.getSalvageSeed(entity);
                seed /= 321L;
                seed *= (Global.getSector().getClock().getMonth() + 10);
                random = new Random(seed);
            } else {
                random = new Random();
            }
        }
        mem.set(key, random, 30f);
        
        return random;
    }
    
    
    public int getNumMarineTokens() {
        //if (true) return MAX_MARINE_TOKENS;
        int num = (int) Math.round(temp.raidMult / RE_PER_MARINE_TOKEN); 
        if (num < MIN_MARINE_TOKENS) num = MIN_MARINE_TOKENS;
        if (num > MAX_MARINE_TOKENS) num = MAX_MARINE_TOKENS;
        return num;
    }
    
    protected MutableStat getMarineLossesStat(List<GroundRaidObjectivePlugin> data) {
        MutableStat stat = new MutableStat(1f);
        
        float total = 0f;
        float assignedTokens = 0f;
        for (GroundRaidObjectivePlugin curr : data) {
            RaidDangerLevel danger = curr.getDangerLevel();
            total += danger.marineLossesMult * (float) curr.getMarinesAssigned();
            assignedTokens += curr.getMarinesAssigned();
        }
        
        float danger = total / Math.max(1f, assignedTokens);
        
        float hazard = 1f;
        if (market != null) hazard = market.getHazardValue();
        
        float reMult = 1f;
        if (temp.raidMult > MIN_RE_TO_REDUCE_MARINE_LOSSES) {
            float extra = (temp.raidMult - MIN_RE_TO_REDUCE_MARINE_LOSSES) / (1f - MIN_RE_TO_REDUCE_MARINE_LOSSES);
//          extra = (float) Math.sqrt(extra);
//          extra *= 0.5f;
            extra = MAX_MARINE_LOSS_REDUCTION_MULT + (1f - MAX_MARINE_LOSS_REDUCTION_MULT) * (1f - extra);
            reMult = extra;
        } else if (temp.raidMult < RE_PER_MARINE_TOKEN) {
            float extra = 1f + (RE_PER_MARINE_TOKEN - temp.raidMult) / RE_PER_MARINE_TOKEN;
            reMult = extra;
        }
        
        if (market != null && reMult < 1f) {
            float minMarinesForAssignedTokens = getMarinesFor(market, (int) Math.round(assignedTokens));
            float actualMarines = Global.getSector().getPlayerFleet().getCargo().getMarines();
            if (actualMarines > minMarinesForAssignedTokens && actualMarines > 0) {
                reMult *= 0.5f + (0.5f * minMarinesForAssignedTokens / actualMarines);
            }
        }
 
        float reservesMult = 1f;
        float maxTokens = getNumMarineTokens();
        if (maxTokens > assignedTokens) {
            reservesMult = 1f - (maxTokens - assignedTokens) * LOSS_REDUCTION_PER_RESERVE_TOKEN;
            reservesMult = Math.max(0.5f, reservesMult);
        }
        
        float e = getDefenderIncreaseRaw(market);
        float per = getRaidDefenderIncreasePerRaid();
        float prep = e / per * LOSS_INCREASE_PER_RAID;
        
        stat.modifyMultAlways("danger", danger, "Danger level of objectives");
        stat.modifyMult("hazard", hazard, "Colony hazard rating");
        if (reMult < 1f) {
            stat.modifyMultAlways("reMult", reMult, "High raid effectiveness");
        } else if (reMult > 1f) {
            stat.modifyMultAlways("reMult", reMult, "Low raid effectiveness");
        }
        
        if (reservesMult < 1f && assignedTokens > 0) {
            stat.modifyMultAlways("reservesMult", reservesMult, "Forces held in reserve");
        }
//      else if (reservesMult >= 1f && assignedTokens > 0) {
//          stat.modifyMultAlways("reservesMult", 1f, "No forces held in reserve");
//      }
        
        stat.modifyMult("prep", 1f + prep, "Increased defender preparedness");
        
        stat.applyMods(playerFleet.getStats().getDynamic().getStat(Stats.PLANETARY_OPERATIONS_CASUALTIES_MULT));
        
        ListenerUtil.modifyMarineLossesStatPreRaid(market, data, stat);
        
        return stat;
    }
    
    
 
    protected float getAverageMarineLosses(List<GroundRaidObjectivePlugin> data) {
        MutableStat stat = getMarineLossesStat(data);
        float mult = stat.getModifiedValue();
        if (mult > MAX_MARINE_LOSSES) {
            mult = MAX_MARINE_LOSSES;
        }
        
        float marines = playerFleet.getCargo().getMarines();
        return marines * mult;
    }
    
    protected void addMilitaryResponse() {
        if (market == null) return;
        
        if (!market.getFaction().getCustomBoolean(Factions.CUSTOM_NO_WAR_SIM)) {
            MilitaryResponseParams params = new MilitaryResponseParams(ActionType.HOSTILE, 
                    "player_ground_raid_" + market.getId(), 
                    market.getFaction(),
                    market.getPrimaryEntity(),
                    0.75f,
                    30f);
            market.getContainingLocation().addScript(new MilitaryResponseScript(params));
        }
        List<CampaignFleetAPI> fleets = market.getContainingLocation().getFleets();
        for (CampaignFleetAPI other : fleets) {
            if (other.getFaction() == market.getFaction()) {
                MemoryAPI mem = other.getMemoryWithoutUpdate();
                Misc.setFlagWithReason(mem, MemFlags.MEMORY_KEY_MAKE_HOSTILE_WHILE_TOFF, "raidAlarm", true, 1f);
            }
        }
    }
    
    protected void raidConfirm(boolean secret) {
        if (temp.raidType == null) {
            raidNeverMind();
            return;
        }
        
        temp.secret = secret;
        
//      if (temp.raidType == RaidType.VALUABLE) {
//          dialog.getVisualPanel().showImagePortion("illustrations", "raid_valuables_result", 640, 400, 0, 0, 480, 300);
//      } else if (temp.raidType == RaidType.DISRUPT) {
//          dialog.getVisualPanel().showImagePortion("illustrations", "raid_disrupt_result", 640, 400, 0, 0, 480, 300);
//      }
        
        Random random = getRandom();
        //random = new Random();
        
        if (!DebugFlags.MARKET_HOSTILITIES_DEBUG) {
            Misc.increaseMarketHostileTimeout(market, HOSTILE_ACTIONS_TIMEOUT_DAYS);
        }
        
        addMilitaryResponse();
        
        
        // if done here, increases marine casualties from this raid - move it down later
//      if (market != null) {
//          applyDefenderIncreaseFromRaid(market);
//      }
        
        setRaidCooldown(getRaidCooldownMax());
 
        //RecentUnrest.get(market).add(3, Misc.ucFirst(reason));
        int stabilityPenalty = 0;
        if (!temp.nonMarket) {
            String reason = "Recently raided";
            if (Misc.isPlayerFactionSetUp()) {
                reason = playerFaction.getDisplayName() + " raid";
            }
            float raidMultForStabilityPenalty = temp.raidMult;
            if (temp.objectives != null) {
                float assignedTokens = 0f;
                for (GroundRaidObjectivePlugin curr : temp.objectives) {
                    assignedTokens += curr.getMarinesAssigned();
                }
                raidMultForStabilityPenalty = assignedTokens * 0.1f; 
            }
            
            stabilityPenalty = applyRaidStabiltyPenalty(market, reason, raidMultForStabilityPenalty);
            Misc.setFlagWithReason(market.getMemoryWithoutUpdate(), MemFlags.RECENTLY_RAIDED, 
                                   Factions.PLAYER, true, 30f);
            Misc.setRaidedTimestamp(market);
        }
        
        int marines = playerFleet.getCargo().getMarines();
        float probOfLosses = 1f;
        
        int losses = 0;
        if (random.nextFloat() < probOfLosses) {
            float averageLosses = getAverageMarineLosses(temp.objectives);
            float variance = averageLosses / 4f;
            
            //float randomizedLosses = averageLosses - variance + variance * 2f * random.nextFloat();
            float randomizedLosses = StarSystemGenerator.getNormalRandom(
                            random, averageLosses - variance, averageLosses + variance);
            if (randomizedLosses < 1f) {
                randomizedLosses = random.nextFloat() < randomizedLosses ? 1f : 0f;
            }
            randomizedLosses = Math.round(randomizedLosses);
            losses = (int) randomizedLosses;
            
            if (losses < 0) losses = 0;
            if (losses > marines) losses = marines;
        }
        
        //losses = random.nextInt(marines / 2);
        
        if (losses <= 0) {
            text.addPara("Your forces have not suffered any casualties.");
            temp.marinesLost = 0;
        } else {
            text.addPara("You forces have suffered casualties during the raid.", Misc.getHighlightColor(), "" + losses);
            playerFleet.getCargo().removeMarines(losses);
            temp.marinesLost = losses;
            AddRemoveCommodity.addCommodityLossText(Commodities.MARINES, losses, text);
        }
        
        
        if (!secret) {
            boolean tOn = playerFleet.isTransponderOn();
            boolean hostile = faction.isHostileTo(Factions.PLAYER);
            CustomRepImpact impact = new CustomRepImpact();
            if (market != null) {
                impact.delta = market.getSize() * -0.01f * 1f;
            } else {
                impact.delta = -0.01f;
            }
            if (!hostile && tOn) {
                impact.ensureAtBest = RepLevel.HOSTILE;
            }
            if (impact.delta != 0 && !faction.isNeutralFaction()) {
                Global.getSector().adjustPlayerReputation(
                        new RepActionEnvelope(RepActions.CUSTOM, 
                            impact, null, text, true, true),
                            faction.getId());
            }
        }
        
        if (stabilityPenalty > 0) {
            text.addPara("Stability of " + market.getName() + " reduced by %s.",
                    Misc.getHighlightColor(), "" + stabilityPenalty);
        }
        
//      if (!temp.nonMarket) {
//          if (temp.raidType == RaidType.VALUABLE || true) {
//              text.addPara("The raid was successful in achieving its objectives.");
//          }
//      }
        
        CargoAPI result = performRaid(random, temp.raidMult);
        
        if (market != null) market.reapplyIndustries();
        
        result.sort();
        result.updateSpaceUsed();
        
        temp.raidLoot = result;
        
//      int raidCredits = (int)result.getCredits().get();
//      if (raidCredits < 0) raidCredits = 0;
//      
//      //result.clear();
//      if (raidCredits > 0) {
//          AddRemoveCommodity.addCreditsGainText(raidCredits, text);
//          playerFleet.getCargo().getCredits().add(raidCredits);
//      }
        
        if (temp.xpGained > 0) {
            Global.getSector().getPlayerStats().addXP(temp.xpGained, dialog.getTextPanel());
        }
        if (temp.raidType == RaidType.VALUABLE) {
            if (result.getTotalCrew() + result.getSpaceUsed() + result.getFuel() < 10) {
                dialog.getVisualPanel().showImagePortion("illustrations", "raid_covert_result", 640, 400, 0, 0, 480, 300);
            } else {
                dialog.getVisualPanel().showImagePortion("illustrations", "raid_valuables_result", 640, 400, 0, 0, 480, 300);
            }
        } else if (temp.raidType == RaidType.DISRUPT) {
            dialog.getVisualPanel().showImagePortion("illustrations", "raid_disrupt_result", 640, 400, 0, 0, 480, 300);
        }
        
        boolean withContinue = false;
        
        for (GroundRaidObjectivePlugin curr : temp.objectives) {
            if (curr.withContinueBeforeResult()) {
                withContinue = true;
                break;
            }
        }
        
        if (market != null) {
            applyDefenderIncreaseFromRaid(market);
        }
        
//      if (market.getMemoryWithoutUpdate().getBoolean("$raid_showContinueBeforeResult"))
//      withContinue = true;
        
        if (withContinue) {
            options.clearOptions();
            options.addOption("Continue", RAID_CONFIRM_CONTINUE);
        } else {
            raidConfirmContinue();
        }
    }
    
    public void raidConfirmContinue() {
        //Random random = getRandom();
        String contText = null;
        if (temp.raidType == RaidType.VALUABLE || true) {
            if (!temp.nonMarket) {
                if (temp.raidType == RaidType.VALUABLE || true) {
                    //text.addPara("The raid was successful in achieving its objectives.");
                }
            }
            
//          CargoAPI result = performRaid(random, temp.raidMult);
//          
//          if (market != null) market.reapplyIndustries();
//          
//          result.sort();
//          
//          temp.raidLoot = result;
            
            int raidCredits = (int)temp.raidLoot.getCredits().get();
            if (raidCredits < 0) raidCredits = 0;
            
            //result.clear();
            if (raidCredits > 0) {
                AddRemoveCommodity.addCreditsGainText(raidCredits, text);
                playerFleet.getCargo().getCredits().add(raidCredits);
            }
            
//          if (temp.xpGained > 0) {
//              Global.getSector().getPlayerStats().addXP(temp.xpGained, dialog.getTextPanel());
//          }
            
            if (!temp.raidLoot.isEmpty()) {
                contText = "Pick through the spoils";
            }
            temp.contText = contText;
            
            float assignedTokens = 0f;
            List<Industry> disrupted = new ArrayList<Industry>();
            for (GroundRaidObjectivePlugin curr : temp.objectives) {
                assignedTokens += curr.getMarinesAssigned();
                if (curr instanceof DisruptIndustryRaidObjectivePluginImpl && curr.getSource() != null) {
                    disrupted.add(curr.getSource());
                }
            }
            
            RaidResultData data = new RaidResultData();
            data.market = market;
            data.entity = entity;
            data.objectives = temp.objectives;
            data.type = temp.raidType;
            data.raidEffectiveness = temp.raidMult;
            data.xpGained = temp.xpGained;
            data.marinesTokensInReserve = (int) Math.round(getNumMarineTokens() - assignedTokens);
            data.marinesTokens = getNumMarineTokens();
            data.marinesLost = temp.marinesLost;
            
            ListenerUtil.reportRaidObjectivesAchieved(data, dialog, memoryMap);
            
            if (temp.raidType == RaidType.VALUABLE) {
                ListenerUtil.reportRaidForValuablesFinishedBeforeCargoShown(dialog, market, temp, temp.raidLoot);
            } else if (temp.raidType == RaidType.DISRUPT) {
                for (Industry curr : disrupted) {
                    ListenerUtil.reportRaidToDisruptFinished(dialog, market, temp, curr);
                }
            }
            
        }
        
        Global.getSoundPlayer().playUISound("ui_raid_finished", 1f, 1f);
        
        FireBest.fire(null, dialog, memoryMap, "PostGroundRaid");
    }
    
    protected CargoAPI performRaid(Random random, float raidEffectiveness) {
        CargoAPI result = Global.getFactory().createCargo(true);
        
        float leftoverRE = (int)Math.round(raidEffectiveness * 100f) % (int)Math.round(RE_PER_MARINE_TOKEN * 100f);
        leftoverRE /= 100f;
        if (raidEffectiveness < RE_PER_MARINE_TOKEN) {
            //leftoverRE = leftoverRE - RE_PER_MARINE_TOKEN;
            leftoverRE = 0f;
        }
        
        long baseSeed = random.nextLong();
        
        int xp = 0;
        for (GroundRaidObjectivePlugin plugin : temp.objectives) {
            float lootMult = 1f + leftoverRE / Math.max(RE_PER_MARINE_TOKEN, raidEffectiveness);
            
            Random curr = new Random(Misc.seedUniquifier() ^ (baseSeed * plugin.getClass().getName().hashCode()));
            xp += plugin.performRaid(result, curr, lootMult, dialog.getTextPanel());
        }
 
        temp.xpGained = xp;
        
        return result;
    }
    
    
    protected void raidNeverMind() {
        if (temp.nonMarket) {
            raidNonMarket();
        } else {
            raidMenu();
        }
    }
    
    
    protected void raidShowLoot() {
        dialog.getVisualPanel().showLoot("Spoils", temp.raidLoot, false, true, true, new CoreInteractionListener() {
            public void coreUIDismissed() {
                //dialog.dismiss();
                finishedRaidOrBombard();
            }
        });
    }
    
    
    protected void printStationState() {
        StationState state = getStationState();
        if (state == StationState.REPAIRS || state == StationState.UNDER_CONSTRUCTION) {
            CampaignFleetAPI fleet = Misc.getStationBaseFleet(market);
            String name = "orbital station";
            if (fleet != null) {
                FleetMemberAPI flagship = fleet.getFlagship();
                if (flagship != null) {
                    name = flagship.getVariant().getDesignation().toLowerCase();
                }
            }
            if (state == StationState.REPAIRS) {
                text.addPara("The " + name + " has suffered extensive damage and is not currently combat-capable.");
            } else {
                text.addPara("The " + name + " is under construction and is not currently combat-capable.");
            }
        }
    }
 
    
    protected void engage() {
        final SectorEntityToken entity = dialog.getInteractionTarget();
        final MemoryAPI memory = getEntityMemory(memoryMap);
 
        final CampaignFleetAPI primary = getInteractionTargetForFIDPI();
        
        dialog.setInteractionTarget(primary);
        
        final FIDConfig config = new FIDConfig();
        config.leaveAlwaysAvailable = true;
        config.showCommLinkOption = false;
        config.showEngageText = false;
        config.showFleetAttitude = false;
        config.showTransponderStatus = false;
        //config.showWarningDialogWhenNotHostile = false;
        config.alwaysAttackVsAttack = true;
        config.impactsAllyReputation = true;
//      config.impactsEnemyReputation = false;
//      config.pullInAllies = false;
//      config.pullInEnemies = false;
//      config.lootCredits = false;
        
//      config.firstTimeEngageOptionText = "Engage the automated defenses";
//      config.afterFirstTimeEngageOptionText = "Re-engage the automated defenses";
        config.noSalvageLeaveOptionText = "Continue";
        
        config.dismissOnLeave = false;
        config.printXPToDialog = true;
        
        config.straightToEngage = true;
        
        CampaignFleetAPI station = getStationFleet();
        config.playerAttackingStation = station != null;
        
        final FleetInteractionDialogPluginImpl plugin = new FleetInteractionDialogPluginImpl(config);
        
        final InteractionDialogPlugin originalPlugin = dialog.getPlugin();
        config.delegate = new BaseFIDDelegate() {
            @Override
            public void notifyLeave(InteractionDialogAPI dialog) {
                if (primary.isStationMode()) {
                    primary.getMemoryWithoutUpdate().clear();
                    primary.clearAssignments();
                    //primary.deflate();
                }
                
                dialog.setPlugin(originalPlugin);
                dialog.setInteractionTarget(entity);
                
                boolean quickExit = entity.hasTag(Tags.NON_CLICKABLE);
                
                if (!Global.getSector().getPlayerFleet().isValidPlayerFleet() || quickExit) {
                    dialog.getOptionPanel().clearOptions();
                    dialog.getOptionPanel().addOption("Leave", "marketLeave");
                    dialog.getOptionPanel().setShortcut("marketLeave", Keyboard.KEY_ESCAPE, false, false, false, true);
    
                    dialog.showTextPanel();
                    dialog.setPromptText("You decide to...");
                    dialog.getVisualPanel().finishFadeFast();
                    text.updateSize();
                    
//                  dialog.hideVisualPanel();
//                  dialog.getVisualPanel().finishFadeFast();
//                  dialog.hideTextPanel();
//                  dialog.dismiss();
                    return;
                }
                
                if (plugin.getContext() instanceof FleetEncounterContext) {
                    FleetEncounterContext context = (FleetEncounterContext) plugin.getContext();
                    if (context.didPlayerWinMostRecentBattleOfEncounter()) {
                        // may need to do something here re: station being defeated & timed out
                        //FireBest.fire(null, dialog, memoryMap, "BeatDefendersContinue");
                    } else {
                        //dialog.dismiss();
                    }
                    
                    if (context.isEngagedInHostilities()) {
                        dialog.getInteractionTarget().getMemoryWithoutUpdate().set("$tradeMode", "NONE", 0);
                    }
                    
                    showDefenses(context.isEngagedInHostilities());
                } else {
                    showDefenses(false);
                }
                dialog.getVisualPanel().finishFadeFast();
                
                //dialog.dismiss();
            }
            @Override
            public void battleContextCreated(InteractionDialogAPI dialog, BattleCreationContext bcc) {
                //bcc.aiRetreatAllowed = false;
                bcc.objectivesAllowed = false;
            }
            @Override
            public void postPlayerSalvageGeneration(InteractionDialogAPI dialog, FleetEncounterContext context, CargoAPI salvage) {
            }
            
        };
        
        dialog.setPlugin(plugin);
        plugin.init(dialog);
        
    }
 
    protected CampaignFleetAPI getStationFleet() {
        CampaignFleetAPI station = Misc.getStationFleet(market);
        if (station == null) return null;
        
        if (station.getFleetData().getMembersListCopy().isEmpty()) return null;
        
        return station;
    }
    
    protected CampaignFleetAPI getInteractionTargetForFIDPI() {
        CampaignFleetAPI primary = getStationFleet();
        if (primary == null) {
            CampaignFleetAPI best = null;
            float minDist = Float.MAX_VALUE;
            for (CampaignFleetAPI fleet : Misc.getNearbyFleets(entity, 2000)) {
                if (fleet.getBattle() != null) continue;
                
                if (fleet.getFaction() != market.getFaction()) continue;
                if (fleet.getFleetData().getNumMembers() <= 0) continue;
                
                float dist = Misc.getDistance(entity.getLocation(), fleet.getLocation());
                dist -= entity.getRadius();
                dist -= fleet.getRadius();
                
                if (dist < Misc.getBattleJoinRange() ) {
                    if (dist < minDist) {
                        best = fleet;
                        minDist = dist;
                    }
                }
            }
            primary = best;
        } else {
            //primary.setLocation(entity.getLocation().x, entity.getLocation().y);
        }
        return primary;
    }
    
    public static enum StationState {
        NONE,
        OPERATIONAL,
        UNDER_CONSTRUCTION,
        REPAIRS
    }
    
    protected StationState getStationState() {
        CampaignFleetAPI fleet = Misc.getStationFleet(market);
        boolean destroyed = false;
        if (fleet == null) {
            fleet = Misc.getStationBaseFleet(market);
            if (fleet != null) {
                destroyed = true;
            }
        }
        
        if (fleet == null) return StationState.NONE;
        
        MarketAPI market = Misc.getStationMarket(fleet);
        if (market != null) {
            for (Industry ind : market.getIndustries()) {
                if (ind.getSpec().hasTag(Industries.TAG_STATION)) {
                    if (ind.isBuilding() && !ind.isDisrupted() && !ind.isUpgrading()) {
                        return StationState.UNDER_CONSTRUCTION;
                    }
                }
            }
        }
        
        if (destroyed) return StationState.REPAIRS;
        
        return StationState.OPERATIONAL;
    }
    
    
    public static int applyRaidStabiltyPenalty(MarketAPI target, String desc, float re) {
        int penalty = 0;
        if (re >= 0.79f) penalty = 3;
        else if (re >= 0.59f) penalty = 2;
        else if (re >= 0.29f) penalty = 1;
        if (penalty > 0) {
            RecentUnrest.get(target).add(penalty, desc);
        }
        return penalty;
    }
    
    public static int applyRaidStabiltyPenalty(MarketAPI target, String desc, float re, float maxPenalty) {
        int penalty = Math.round((0.45f + maxPenalty) * re);
        if (penalty > 0) {
            RecentUnrest.get(target).add(penalty, desc);
        }
        return penalty;
    }
    
    
    public static StatModValueGetter statPrinter(final boolean withNegative) {
        return new StatModValueGetter() {
            public String getPercentValue(StatMod mod) {
                String prefix = mod.getValue() > 0 ? "+" : "";
                return prefix + (int)(mod.getValue()) + "%";
            }
            public String getMultValue(StatMod mod) {
                return Strings.X + "" + Misc.getRoundedValue(mod.getValue());
            }
            public String getFlatValue(StatMod mod) {
                String prefix = mod.getValue() > 0 ? "+" : "";
                return prefix + (int)(mod.getValue()) + "";
            }
            public Color getModColor(StatMod mod) {
                if (withNegative && mod.getValue() < 1f) return Misc.getNegativeHighlightColor();
                return null;
            }
        };
    }
    
    
    public static int getBombardmentCost(MarketAPI market, CampaignFleetAPI fleet) {
        float str = getDefenderStr(market, true);
        int result = (int) (str * Global.getSettings().getFloat("bombardFuelFraction"));
        if (result < 2) result = 2;
        if (fleet != null) {
            float bomardBonus = Misc.getFleetwideTotalMod(fleet, Stats.FLEET_BOMBARD_COST_REDUCTION, 0f);
            result -= bomardBonus;
            if (result < 0) result = 0;
        }
        return result;
    }
    
    public static int getTacticalBombardmentStabilityPenalty() {
        return (int) Global.getSettings().getFloat("bombardTacticalStability");
    }
    public static int getSaturationBombardmentStabilityPenalty() {
        return (int) Global.getSettings().getFloat("bombardSaturationStability");
    }
    
 
    protected void bombardMenu() {
        float width = 350;
        float opad = 10f;
        float small = 5f;
        
        Color h = Misc.getHighlightColor();
        Color b = Misc.getNegativeHighlightColor();
        
        dialog.getVisualPanel().showImagePortion("illustrations", "bombard_prepare", 640, 400, 0, 0, 480, 300);
 
        StatBonus defender = market.getStats().getDynamic().getMod(Stats.GROUND_DEFENSES_MOD);
        
        float bomardBonus = Misc.getFleetwideTotalMod(playerFleet, Stats.FLEET_BOMBARD_COST_REDUCTION, 0f);
        String increasedBombardKey = "core_addedBombard";
        StatBonus bombardBonusStat = new StatBonus();
        if (bomardBonus > 0) {
            bombardBonusStat.modifyFlat(increasedBombardKey, -bomardBonus, "Specialized fleet bombardment capability");
        }
        
        float defenderStr = (int) Math.round(defender.computeEffective(0f));
        defenderStr -= bomardBonus;
        if (defenderStr < 0) defenderStr = 0;
        
        temp.defenderStr = defenderStr;
        
        TooltipMakerAPI info = text.beginTooltip();
        
        info.setParaSmallInsignia();
        
        String has = faction.getDisplayNameHasOrHave();
        String is = faction.getDisplayNameIsOrAre();
        boolean hostile = faction.isHostileTo(Factions.PLAYER);
        boolean tOn = playerFleet.isTransponderOn();
        float initPad = 0f;
        if (!hostile) {
            info.addPara(Misc.ucFirst(faction.getDisplayNameWithArticle()) + " " + is + 
                    " not currently hostile. A bombardment is a major enough hostile action that it can't be concealed, " +
                    "regardless of transponder status.",
                    initPad, faction.getBaseUIColor(), faction.getDisplayNameWithArticleWithoutArticle());
            initPad = opad;
        }
 
        info.addPara("Starship fuel can be easily destabilized, unlocking the destructive " +
                "potential of the antimatter it contains. Ground defenses can counter " +
                "a bombardment, though in practice it only means that more fuel is required to achieve " +
                "the same result.", initPad);
                
        
        if (bomardBonus > 0) {
            info.addPara("Effective ground defense strength: %s", opad, h, "" + (int)defenderStr);
        } else {
            info.addPara("Ground defense strength: %s", opad, h, "" + (int)defenderStr);
        }
        info.addStatModGrid(width, 50, opad, small, defender, true, statPrinter(true));
        if (!bombardBonusStat.isUnmodified()) {
            info.addStatModGrid(width, 50, opad, 3f, bombardBonusStat, true, statPrinter(false));
        }
        
        text.addTooltip();
 
//      text.addPara("A tactical bombardment will only hit military targets and costs less fuel. A saturation " +
//              "bombardment will devastate the whole colony, and only costs marginally more fuel, as the non-military " +
//              "targets don't have nearly the same degree of hardening.");
        
        temp.bombardCost = getBombardmentCost(market, playerFleet);
        
        int fuel = (int) playerFleet.getCargo().getFuel();
        boolean canBombard = fuel >= temp.bombardCost;
        
        LabelAPI label = text.addPara("A bombardment requires %s fuel. " +
                                      "You have %s fuel.",
                h, "" + temp.bombardCost, "" + fuel);
        label.setHighlight("" + temp.bombardCost, "" + fuel);
        label.setHighlightColors(canBombard ? h : b, h);
 
        options.clearOptions();
        
        options.addOption("Prepare a tactical bombardment", BOMBARD_TACTICAL);
        options.addOption("Prepare a saturation bombardment", BOMBARD_SATURATION);
        
        if (DebugFlags.MARKET_HOSTILITIES_DEBUG) {
            canBombard = true;
        }
        if (!canBombard) {
            options.setEnabled(BOMBARD_TACTICAL, false);
            options.setTooltip(BOMBARD_TACTICAL, "Not enough fuel.");
            options.setEnabled(BOMBARD_SATURATION, false);
            options.setTooltip(BOMBARD_SATURATION, "Not enough fuel.");
        }
 
        options.addOption("Go back", RAID_GO_BACK);
        options.setShortcut(RAID_GO_BACK, Keyboard.KEY_ESCAPE, false, false, false, true);
    }
    
    
    protected void addConfirmOptions() {
        options.clearOptions();
//      if (temp.isSurpriseRaid) {
//          options.addOption("Launch surprise raid", RAID_CONFIRM);
//      } else {
            //options.addOption("Launch full-scale raid", RAID_CONFIRM);
            options.addOption("Launch raid", RAID_CONFIRM);
//      }
        
        boolean tOn = playerFleet.isTransponderOn();
            
        //if (!temp.nonMarket) {
        if (market != null && !market.isPlanetConditionMarketOnly()) {
            options.addOption("Make special efforts to keep your preparations secret, then proceed", RAID_CONFIRM_STORY);
            String req = "";
            if (tOn) {
                req = "\n\nRequires transponder to be turned off";
                options.setEnabled(RAID_CONFIRM_STORY, false);
            }
            options.setTooltip(RAID_CONFIRM_STORY, "Suffer no penalty to your standing with " + market.getFaction().getDisplayNameWithArticle() + ". " +
                    "Will not help if forced to turn your transponder on by patrols arriving to investigate the raid." + req);
            options.setTooltipHighlightColors(RAID_CONFIRM_STORY, market.getFaction().getBaseUIColor(), Misc.getNegativeHighlightColor());
            options.setTooltipHighlights(RAID_CONFIRM_STORY, market.getFaction().getDisplayNameWithArticleWithoutArticle(), req.isEmpty() ? req : req.substring(2));
            StoryOptionParams params = new StoryOptionParams(RAID_CONFIRM_STORY, 1, "noRepPenaltyRaid", Sounds.STORY_POINT_SPEND_LEADERSHIP,
                    "Secretly raided " + market.getName() + "");
            SetStoryOption.set(dialog, params, 
                new BaseOptionStoryPointActionDelegate(dialog, params) {
                    @Override
                    public void confirm() {
                        super.confirm();
                        raidConfirm(true);
                    }
            });
        }
            
            
        options.addOption("Never mind", RAID_NEVER_MIND);
        options.setShortcut(RAID_NEVER_MIND, Keyboard.KEY_ESCAPE, false, false, false, true);
        
        boolean hostile = faction.isHostileTo(Factions.PLAYER);
        if (tOn && !hostile && !faction.isNeutralFaction()) {
            options.addOptionConfirmation(RAID_CONFIRM,
                    "The " + faction.getDisplayNameLong() + 
                    " " + faction.getDisplayNameIsOrAre() + 
                    " not currently hostile, and you have been positively identified. " +
                    "Are you sure you want to engage in open hostilities?", "Yes", "Never mind");
        }
    }
    
    public static List<Industry> getTacticalBombardmentTargets(MarketAPI market) {
        int dur = getBombardDisruptDuration();
        List<Industry> targets = new ArrayList<Industry>();
        for (Industry ind : market.getIndustries()) {
            if (ind.getSpec().hasTag(Industries.TAG_TACTICAL_BOMBARDMENT)) {
                if (ind.getDisruptedDays() >= dur * 0.8f) continue;
                targets.add(ind);
            }
        }
        return targets;
    }
    
    protected void bombardTactical() {
        
        temp.bombardType = BombardType.TACTICAL; 
        
        boolean hostile = faction.isHostileTo(Factions.PLAYER);
        temp.willBecomeHostile.clear();
        temp.willBecomeHostile.add(faction);    
        
        float opad = 10f;
        float small = 5f;
        
        Color h = Misc.getHighlightColor();
        Color b = Misc.getNegativeHighlightColor();
        
        
        int dur = getBombardDisruptDuration();
        
        List<Industry> targets = getTacticalBombardmentTargets(market);
        temp.bombardmentTargets.clear();
        temp.bombardmentTargets.addAll(targets);
        
        if (targets.isEmpty()) {
            text.addPara(market.getName() + " does not have any undisrupted military targets that would be affected by a tactical bombardment.");
            addBombardNeverMindOption();
            return; 
        }
        
        
        int fuel = (int) playerFleet.getCargo().getFuel();
        text.addPara("A tactical bombardment will destabilize the colony, and will also disrupt the " +
                "following military targets for approximately %s days:",
                     h, "" + dur);
        
        TooltipMakerAPI info = text.beginTooltip();
        
        info.setParaSmallInsignia();
        info.setParaFontDefault();
        
        info.setBulletedListMode(BaseIntelPlugin.INDENT);
        float initPad = 0f;
        for (Industry ind : targets) {
            //info.addPara(ind.getCurrentName(), faction.getBaseUIColor(), initPad);
            info.addPara(ind.getCurrentName(), initPad);
            initPad = 3f;
        }
        info.setBulletedListMode(null);
        
        text.addTooltip();
        
        text.addPara("The bombardment requires %s fuel. " +
                     "You have %s fuel.",
                     h, "" + temp.bombardCost, "" + fuel);
        
        addBombardConfirmOptions();
    }
    
    protected void bombardSaturation() {
        
        temp.bombardType = BombardType.SATURATION;
 
        temp.willBecomeHostile.clear();
        temp.willBecomeHostile.add(faction);
        
        List<FactionAPI> nonHostile = new ArrayList<FactionAPI>();
        nonHostile.add(faction);
        for (FactionAPI faction : Global.getSector().getAllFactions()) {
            if (temp.willBecomeHostile.contains(faction)) continue;
            if (faction.getCustomBoolean(Factions.CUSTOM_CARES_ABOUT_ATROCITIES)) {
                boolean hostile = faction.isHostileTo(Factions.PLAYER);
                temp.willBecomeHostile.add(faction);
                if (!hostile) {
                    nonHostile.add(faction);
                }
            }
            
        }
        
        float opad = 10f;
        float small = 5f;
        
        Color h = Misc.getHighlightColor();
        Color b = Misc.getNegativeHighlightColor();
        
        
        int dur = getBombardDisruptDuration();
        
        List<Industry> targets = new ArrayList<Industry>();
        for (Industry ind : market.getIndustries()) {
            if (!ind.getSpec().hasTag(Industries.TAG_NO_SATURATION_BOMBARDMENT)) {
                if (ind.getDisruptedDays() >= dur * 0.8f) continue;
                targets.add(ind);
            }
        }
        temp.bombardmentTargets.clear();
        temp.bombardmentTargets.addAll(targets);
        
        boolean destroy = market.getSize() <= getBombardDestroyThreshold();
        if (Misc.isStoryCritical(market)) destroy = false;
        
        int fuel = (int) playerFleet.getCargo().getFuel();
        if (destroy) {
            text.addPara("A saturation bombardment of a colony this size will destroy it utterly.");
        } else {
            text.addPara("A saturation bombardment will destabilize the colony, reduce its population, " +
                    "and disrupt all operations for a long time.");
        }
        
        
//      TooltipMakerAPI info = text.beginTooltip();
//      info.setParaFontDefault();
//      
//      info.setBulletedListMode(BaseIntelPlugin.INDENT);
//      float initPad = 0f;
//      for (Industry ind : targets) {
//          //info.addPara(ind.getCurrentName(), faction.getBaseUIColor(), initPad);
//          info.addPara(ind.getCurrentName(), initPad);
//          initPad = 3f;
//      }
//      info.setBulletedListMode(null);
//      
//      text.addTooltip();
        
 
        if (nonHostile.isEmpty()) {
            text.addPara("An atrocity of this scale can not be hidden, but any factions that would " +
                    "be dismayed by such actions are already hostile to you.");
        } else {
            text.addPara("An atrocity of this scale can not be hidden, " +
                         "and will make the following factions hostile:");
        }
        
        if (!nonHostile.isEmpty()) {
            TooltipMakerAPI info = text.beginTooltip();
            info.setParaFontDefault();
            
            info.setBulletedListMode(BaseIntelPlugin.INDENT);
            float initPad = 0f;
            for (FactionAPI fac : nonHostile) {
                info.addPara(Misc.ucFirst(fac.getDisplayName()), fac.getBaseUIColor(), initPad);
                initPad = 3f;
            }
            info.setBulletedListMode(null);
            
            text.addTooltip();
        }
        
        text.addPara("The bombardment requires %s fuel. " +
                     "You have %s fuel.",
                     h, "" + temp.bombardCost, "" + fuel);
        
        addBombardConfirmOptions();
    }
    
    protected void bombardConfirm() {
        
        if (temp.bombardType == null) {
            bombardNeverMind();
            return;
        }
        
        if (temp.bombardType == BombardType.TACTICAL) {
            dialog.getVisualPanel().showImagePortion("illustrations", "bombard_tactical_result", 640, 400, 0, 0, 480, 300);
        } else {
            dialog.getVisualPanel().showImagePortion("illustrations", "bombard_saturation_result", 640, 400, 0, 0, 480, 300);
        }
        
        Random random = getRandom();
        
        if (!DebugFlags.MARKET_HOSTILITIES_DEBUG) {
            float timeout = TACTICAL_BOMBARD_TIMEOUT_DAYS;
            if (temp.bombardType == BombardType.SATURATION) {
                timeout = SATURATION_BOMBARD_TIMEOUT_DAYS;
            }
            Misc.increaseMarketHostileTimeout(market, timeout);
            
            timeout *= 0.7f;
            
            for (MarketAPI curr : Global.getSector().getEconomy().getMarkets(market.getContainingLocation())) {
                if (curr == market) continue;
                boolean cares = curr.getFaction().getCustomBoolean(Factions.CUSTOM_CARES_ABOUT_ATROCITIES);
                cares &= temp.bombardType == BombardType.SATURATION;
                
                if (curr.getFaction().isNeutralFaction()) continue;
                if (curr.getFaction().isPlayerFaction()) continue;
                if (curr.getFaction().isHostileTo(market.getFaction()) && !cares) continue;
                
                Misc.increaseMarketHostileTimeout(curr, timeout);
            }
        }
        
        addMilitaryResponse();
        
        playerFleet.getCargo().removeFuel(temp.bombardCost);
        AddRemoveCommodity.addCommodityLossText(Commodities.FUEL, temp.bombardCost, text);
    
        for (FactionAPI curr : temp.willBecomeHostile) {
            CustomRepImpact impact = new CustomRepImpact();
            impact.delta = market.getSize() * -0.01f * 1f;
            impact.ensureAtBest = RepLevel.HOSTILE;
            if (temp.bombardType == BombardType.SATURATION) {
                if (curr == faction) {
                    impact.ensureAtBest = RepLevel.VENGEFUL;
                }
                impact.delta = market.getSize() * -0.01f * 1f;
            }
            Global.getSector().adjustPlayerReputation(
                new RepActionEnvelope(RepActions.CUSTOM, 
                    impact, null, text, true, true),
                    curr.getId());
        }
    
        if (temp.bombardType == BombardType.SATURATION) {
            int atrocities = (int) Global.getSector().getCharacterData().getMemoryWithoutUpdate().getFloat(MemFlags.PLAYER_ATROCITIES);
            atrocities++;
            Global.getSector().getCharacterData().getMemoryWithoutUpdate().set(MemFlags.PLAYER_ATROCITIES, atrocities);
            
            if (market != null && market.getFaction() != null) {
                MemoryAPI mem = market.getFaction().getMemoryWithoutUpdate();
                int count = mem.getInt(MemFlags.FACTION_SATURATION_BOMBARED_BY_PLAYER);
                count++;
                mem.set(MemFlags.FACTION_SATURATION_BOMBARED_BY_PLAYER, count);
            }
        }
        
        
        int stabilityPenalty = getTacticalBombardmentStabilityPenalty();
        if (temp.bombardType == BombardType.SATURATION) {
            stabilityPenalty = getSaturationBombardmentStabilityPenalty();
        }
        boolean destroy = temp.bombardType == BombardType.SATURATION && market.getSize() <= getBombardDestroyThreshold();
        if (Misc.isStoryCritical(market)) destroy = false;
        
        if (stabilityPenalty > 0 && !destroy) {
            String reason = "Recently bombarded";
            if (Misc.isPlayerFactionSetUp()) {
                reason = playerFaction.getDisplayName() + " bombardment";
            }
            RecentUnrest.get(market).add(stabilityPenalty, reason);
            text.addPara("Stability of " + market.getName() + " reduced by %s.",
                    Misc.getHighlightColor(), "" + stabilityPenalty);
        }
        
        if (market.hasCondition(Conditions.HABITABLE) && !market.hasCondition(Conditions.POLLUTION)) {
            market.addCondition(Conditions.POLLUTION);
        }
        
        if (!destroy) {
            for (Industry curr : temp.bombardmentTargets) {
                int dur = getBombardDisruptDuration();
                dur *= StarSystemGenerator.getNormalRandom(random, 1f, 1.25f);
                curr.setDisrupted(dur);
            }
        }
        
        
        
        if (temp.bombardType == BombardType.TACTICAL) {
            text.addPara("Military operations disrupted.");
            
            ListenerUtil.reportTacticalBombardmentFinished(dialog, market, temp);
        } else if (temp.bombardType == BombardType.SATURATION) {
            if (destroy) {
                DecivTracker.decivilize(market, true);
                text.addPara(market.getName() + " destroyed.");
            } else {
                int prevSize = market.getSize();
                CoreImmigrationPluginImpl.reduceMarketSize(market);
                if (prevSize == market.getSize()) {
                    text.addPara("All operations disrupted.");
                } else {
                    text.addPara("All operations disrupted. Colony size reduced to %s.", 
                            Misc.getHighlightColor()
                            , "" + market.getSize());
                }
                
            }
            ListenerUtil.reportSaturationBombardmentFinished(dialog, market, temp);
        }
        
        if (dialog != null && dialog.getPlugin() instanceof RuleBasedDialog) {
            if (dialog.getInteractionTarget() != null &&
                    dialog.getInteractionTarget().getMarket() != null) {
                Global.getSector().setPaused(false);
                dialog.getInteractionTarget().getMarket().getMemoryWithoutUpdate().advance(0.0001f);
                Global.getSector().setPaused(true);
            }
            ((RuleBasedDialog) dialog.getPlugin()).updateMemory();
        }
        
        Misc.setFlagWithReason(market.getMemoryWithoutUpdate(), MemFlags.RECENTLY_BOMBARDED, 
                              Factions.PLAYER, true, 30f);
 
        if (destroy) {
            if (dialog != null && dialog.getPlugin() instanceof RuleBasedDialog) {
                ((RuleBasedDialog) dialog.getPlugin()).updateMemory();
//              market.getMemoryWithoutUpdate().unset("$tradeMode");
//              entity.getMemoryWithoutUpdate().unset("$tradeMode");
            }
        }
        
        addBombardVisual(market.getPrimaryEntity());
        
        addBombardContinueOption();
    }
    
    
    protected void bombardNeverMind() {
        bombardMenu();      
    }
 
    protected void raidResult() {
        if (temp.raidLoot != null) {
            if (temp.raidLoot.isEmpty()) {
//              clearTemp();
//              showDefenses(true);
                //dialog.dismiss();
                finishedRaidOrBombard();
            } else {
                raidShowLoot();
            }
            return;
        } else {
            //dialog.dismiss();
            finishedRaidOrBombard();
        }
    }
    
    protected void bombardResult() {
        //dialog.dismiss();
        finishedRaidOrBombard();
    }
    
    protected void finishedRaidOrBombard() {
        //showDefenses(true);
    
        new ShowDefaultVisual().execute(null, dialog, Misc.tokenize(""), memoryMap);
        
        //FireAll.fire(null, dialog, memoryMap, "MarketPostOpen");
        dialog.getInteractionTarget().getMemoryWithoutUpdate().set("$menuState", "main", 0);
        if (dialog.getInteractionTarget().getMemoryWithoutUpdate().contains("$tradeMode")) {
            if (market.isPlanetConditionMarketOnly()) {
                dialog.getInteractionTarget().getMemoryWithoutUpdate().unset("$hasMarket");
            }
            dialog.getInteractionTarget().getMemoryWithoutUpdate().set("$tradeMode", "NONE", 0);
        } else {
            // station that's now abandoned
            dialog.getInteractionTarget().getMemoryWithoutUpdate().set("$tradeMode", "OPEN", 0);
        }
        
        if (temp.nonMarket) {
            String trigger = temp.raidContinueTrigger;
            if (trigger == null || trigger.isEmpty()) trigger = "OpenInteractionDialog";
            FireAll.fire(null, dialog, memoryMap, trigger);
        } else {
            FireAll.fire(null, dialog, memoryMap, "PopulateOptions");
        }
        
        clearTemp();
    }
    
    protected void addBombardContinueOption() {
        addBombardContinueOption(null);
    }
    protected void addBombardContinueOption(String text) {
        if (text == null) text = "Continue";
        options.clearOptions();
        options.addOption(text, BOMBARD_RESULT);
    }
    
    
    protected boolean checkDebtEffect() {
        String key = "$debt_effectTimeout";
        if (Global.getSector().getMemoryWithoutUpdate().contains(key)) return false;
        
        //if (true) return true;
        
        // can't exactly melt away in that small an outpost, not that it's outright desertion
        // but it's also not a great place to leave the fleet
        if (market.isPlayerOwned() && market.getSize() <= 3) return false;
        
        MonthlyReport report = SharedData.getData().getPreviousReport();
        
        
        // require 2 months of debt in a row
        if (report.getPreviousDebt() <= 0 || report.getDebt() <= 0) return false;
        
        float debt = report.getDebt() + report.getPreviousDebt();
        float income = report.getRoot().totalIncome;
        if (income < 1) income = 1;
        
        float f = debt / income;
        if (f > 1) f = 1;
        if (f < 0) f = 0;
        // don't penalize minor shortfalls
        if (f < 0.1f) return false;
        
        // and don't reduce crew below a certain minimum
        int crew = playerFleet.getCargo().getCrew();
        int marines = playerFleet.getCargo().getMarines();
        if (crew <= 10 && marines <= 10) return false;
        
        return true;
    }
    
    protected void applyDebtEffect() {
        
        MonthlyReport report = SharedData.getData().getPreviousReport();
        float debt = report.getDebt() + report.getPreviousDebt();
        float income = report.getRoot().totalIncome;
        if (income < 1) income = 1;
        
        float f = debt / income;
        if (f > 1) f = 1;
        if (f < 0) f = 0;
        
        int crew = playerFleet.getCargo().getCrew();
        int marines = playerFleet.getCargo().getMarines();
        
        float maxLossFraction = 0.03f + Math.min(f + 0.05f, 0.2f) * (float) Math.random();
        float marineLossFraction = 0.03f + Math.min(f + 0.05f, 0.2f) * (float) Math.random();
        
        
        int crewLoss = (int) (crew * maxLossFraction);
        if (crewLoss < 2) crewLoss = 2;
        
        int marineLoss = (int) (marines * marineLossFraction);
        if (marineLoss < 2) marineLoss = 2;
        
        dialog.getVisualPanel().showImagePortion("illustrations", "crew_leaving", 640, 400, 0, 0, 480, 300);
        
        text.addPara("The lack of consistent pay over the last few months has caused discontent among your crew. " +
                "A number take this opportunity to leave your employment.");
        
        if (crewLoss < crew) {
            playerFleet.getCargo().removeCrew(crewLoss);
            AddRemoveCommodity.addCommodityLossText(Commodities.CREW, crewLoss, text);
        }
        if (marineLoss <= marines) {
            playerFleet.getCargo().removeMarines(marineLoss);
            AddRemoveCommodity.addCommodityLossText(Commodities.MARINES, marineLoss, text);
        }
        
        String key = "$debt_effectTimeout";
        Global.getSector().getMemoryWithoutUpdate().set(key, true, 30f + (float) Math.random() * 10f);
        
        options.clearOptions();
        options.addOption("Continue", DEBT_RESULT_CONTINUE);
    }
 
    
    public void doGenericRaid(FactionAPI faction, float attackerStr) {
        doGenericRaid(faction, attackerStr, 3f);
    }
    
    public void doGenericRaid(FactionAPI faction, float attackerStr, float maxPenalty) {
        doGenericRaid(faction, attackerStr, maxPenalty, false);
    }
    public void doGenericRaid(FactionAPI faction, float attackerStr, float maxPenalty, boolean allowedRepeat) {
        // needed for pirate raids not to stack
        // not needed anymore, but doesn't hurt anything
        if (!allowedRepeat && Misc.flagHasReason(market.getMemoryWithoutUpdate(), 
                MemFlags.RECENTLY_RAIDED, faction.getId())) {
            return;
        }
        
        float re = getRaidEffectiveness(market, attackerStr);
        if (maxPenalty == 3) {
            applyRaidStabiltyPenalty(market, Misc.ucFirst(faction.getPersonNamePrefix()) + " raid", re);
        } else {
            applyRaidStabiltyPenalty(market, Misc.ucFirst(faction.getPersonNamePrefix()) + " raid", re, maxPenalty);
        }
        //RecentUnrest.get(market).add(3, Misc.ucFirst(faction.getPersonNamePrefix()) + " raid");
        
        Misc.setFlagWithReason(market.getMemoryWithoutUpdate(), MemFlags.RECENTLY_RAIDED, 
                               faction.getId(), true, 30f);
        Misc.setRaidedTimestamp(market);
    }
    
    public boolean doIndustryRaid(FactionAPI faction, float attackerStr, Industry industry, float durMult) {
        temp.raidType = RaidType.DISRUPT;
        temp.target = industry;
        
        StatBonus defenderBase = new StatBonus(); 
        
        StatBonus defender = market.getStats().getDynamic().getMod(Stats.GROUND_DEFENSES_MOD);
        String increasedDefensesKey = "core_addedDefStr";
        float added = getDefenderIncreaseValue(market);
        if (added > 0) {
            defender.modifyFlat(increasedDefensesKey, added, "Increased defender preparedness");
        }
        float defenderStr = (int) Math.round(defender.computeEffective(defenderBase.computeEffective(0f)));
        defender.unmodifyFlat(increasedDefensesKey);
        
        temp.attackerStr = attackerStr;
        temp.defenderStr = defenderStr;
        
        boolean hasForces = true;
        boolean canDisrupt = true;
        temp.raidMult = attackerStr / Math.max(1f, (attackerStr + defenderStr));
        temp.raidMult = Math.round(temp.raidMult * 100f) / 100f;
        
        if (temp.raidMult < VALUABLES_THRESHOLD) {
            hasForces = false;
        }
        if (temp.raidMult < DISRUPTION_THRESHOLD) {
            canDisrupt = false;
        }
        if (!canDisrupt) return false;
        
        
        Random random = getRandom();
        
        applyDefenderIncreaseFromRaid(market);
        
        String reason = faction.getDisplayName() + " raid";
        if (faction.getPersonNamePrefix() != null) {
            reason = Misc.ucFirst(faction.getPersonNamePrefix()) + " raid";
        }
        
        applyRaidStabiltyPenalty(market, reason, temp.raidMult);
        Misc.setFlagWithReason(market.getMemoryWithoutUpdate(), MemFlags.RECENTLY_RAIDED, 
                               faction.getId(), true, 30f);
        Misc.setRaidedTimestamp(market);
        
        if (temp.target != null) {
            float dur = computeBaseDisruptDuration(temp.target);
            dur *= StarSystemGenerator.getNormalRandom(random, 1f, 1.25f);
            dur *= durMult;
            if (dur < 2) dur = 2;
            float already = temp.target.getDisruptedDays();
            temp.target.setDisrupted(already + dur);
        }
        
        return true;
    }
    
    
    public void doBombardment(FactionAPI faction, BombardType type) {
        temp.bombardType = type;
        
        Random random = getRandom();
    
        int dur = getBombardDisruptDuration();
        
        int stabilityPenalty = getTacticalBombardmentStabilityPenalty();
        if (temp.bombardType == BombardType.SATURATION) {
            stabilityPenalty = getSaturationBombardmentStabilityPenalty();
            
            List<Industry> targets = new ArrayList<Industry>();
            for (Industry ind : market.getIndustries()) {
                if (!ind.getSpec().hasTag(Industries.TAG_NO_SATURATION_BOMBARDMENT)) {
                    if (ind.getDisruptedDays() >= dur * 0.8f) continue;
                    targets.add(ind);
                }
            }
            temp.bombardmentTargets.clear();
            temp.bombardmentTargets.addAll(targets);
        } else {
            List<Industry> targets = new ArrayList<Industry>();
            for (Industry ind : market.getIndustries()) {
                if (ind.getSpec().hasTag(Industries.TAG_TACTICAL_BOMBARDMENT)) {
                    if (ind.getDisruptedDays() >= dur * 0.8f) continue;
                    targets.add(ind);
                }
            }
            temp.bombardmentTargets.clear();
            temp.bombardmentTargets.addAll(targets);
        }
        
        
        if (stabilityPenalty > 0) {
            //String reason = faction.getDisplayName() + " bombardment";
            String reason = "Saturation bombardment";
            if (temp.bombardType == BombardType.TACTICAL) {
                reason = "Tactical bombardment";
            }
            
            RecentUnrest.get(market).add(stabilityPenalty, reason);
        }
        
        if (market.hasCondition(Conditions.HABITABLE) && !market.hasCondition(Conditions.POLLUTION)) {
            market.addCondition(Conditions.POLLUTION);
        }
        
        for (Industry curr : temp.bombardmentTargets) {
            dur = getBombardDisruptDuration();
            dur *= StarSystemGenerator.getNormalRandom(random, 1f, 1.25f);
            curr.setDisrupted(dur);
        }
        
        if (temp.bombardType == BombardType.TACTICAL) {
        } else if (temp.bombardType == BombardType.SATURATION) {
            boolean destroy = market.getSize() <= getBombardDestroyThreshold();
            if (Misc.isStoryCritical(market)) destroy = false;
            if (destroy) {
                DecivTracker.decivilize(market, true);
            } else {
                CoreImmigrationPluginImpl.reduceMarketSize(market);
            }
        }
        
        
        Misc.setFlagWithReason(market.getMemoryWithoutUpdate(), MemFlags.RECENTLY_BOMBARDED, 
                               faction.getId(), true, 30f);
        
        addBombardVisual(market.getPrimaryEntity());
    }
    
    
    public static void addBombardVisual(SectorEntityToken target) {
        if (target != null && target.isInCurrentLocation()) {
            int num = (int) (target.getRadius() * target.getRadius() / 300f);
            num *= 2;
            if (num > 150) num = 150;
            if (num < 10) num = 10;
            target.addScript(new BombardmentAnimation(num, target));
        }
    }
    
    public static class BombardmentAnimation implements EveryFrameScript {
        public BombardmentAnimation(int num, SectorEntityToken target) {
            this.num = num;
            this.target = target;
        }
        int num = 0;
        SectorEntityToken target;
        int added = 0;
        float elapsed = 0;
        public boolean runWhilePaused() {
            return false;
        }
        public boolean isDone() {
            return added >= num;
        }
        public void advance(float amount) {
            elapsed += amount * (float) Math.random();
            if (elapsed < 0.03f) return;
            
            elapsed = 0f;
            
            int curr = (int) Math.round(Math.random() * 4);
            if (curr < 1) curr = 0;
            
            Color color = new Color(255, 165, 100, 255);
            
            Vector2f vel = new Vector2f();
            
            if (target.getOrbit() != null && 
                    target.getCircularOrbitRadius() > 0 && 
                    target.getCircularOrbitPeriod() > 0 && 
                    target.getOrbitFocus() != null) {
                float circumference = 2f * (float) Math.PI * target.getCircularOrbitRadius();
                float speed = circumference / target.getCircularOrbitPeriod();
                
                float dir = Misc.getAngleInDegrees(target.getLocation(), target.getOrbitFocus().getLocation()) + 90f;
                vel = Misc.getUnitVectorAtDegreeAngle(dir);
                vel.scale(speed / Global.getSector().getClock().getSecondsPerDay());
            }
            
            for (int i = 0; i < curr; i++) {
                float glowSize = 50f + 50f * (float) Math.random();
                float angle = (float) Math.random() * 360f;
                float dist = (float) Math.sqrt(Math.random()) * target.getRadius();
                
                float factor = 0.5f + 0.5f * (1f - (float)Math.sqrt(dist / target.getRadius()));;
                glowSize *= factor;
                Vector2f loc = Misc.getUnitVectorAtDegreeAngle(angle);
                loc.scale(dist);
                Vector2f.add(loc, target.getLocation(), loc);
                
                Color c2 = Misc.scaleColor(color, factor);
                //c2 = color;
                Misc.addHitGlow(target.getContainingLocation(), loc, vel, glowSize, c2);
                added++;
                
                if (i == 0) {
                    dist = Misc.getDistance(loc, Global.getSector().getPlayerFleet().getLocation());
                    if (dist < HyperspaceTerrainPlugin.STORM_STRIKE_SOUND_RANGE) {
                        float volumeMult = 1f - (dist / HyperspaceTerrainPlugin.STORM_STRIKE_SOUND_RANGE);
                        volumeMult = (float) Math.sqrt(volumeMult);
                        volumeMult *= 0.1f * factor;
                        if (volumeMult > 0) {
                            Global.getSoundPlayer().playSound("mine_explosion", 1f, 1f * volumeMult, loc, Misc.ZERO);
                        }
                    }
                }
            }
        }
    }
    
    
    protected boolean checkMercsLeaving() {
        String key = "$mercs_leaveTimeout";
        if (Global.getSector().getMemoryWithoutUpdate().contains(key)) return false;
        
        if (market.isHidden()) return false;
        if (market.getSize() <= 3) return false;
        
        List<OfficerDataAPI> mercs = Misc.getMercs(playerFleet);
        if (mercs.isEmpty()) return false;
        
        MonthlyReport report = SharedData.getData().getPreviousReport();
        boolean debt = report.getDebt() > 0;
        
        float contractDur = Global.getSettings().getFloat("officerMercContractDur");
        
        for (OfficerDataAPI od : mercs) {
            if (debt && od.getPerson().getMemoryWithoutUpdate().contains(key)) {
                continue;
            }
            float elapsed = Misc.getMercDaysSinceHired(od.getPerson());
            
            if (elapsed > contractDur || (debt && elapsed > 45f)) { // make sure the merc was hired long enough to have seen the debt
                dialog.getInteractionTarget().setActivePerson(od.getPerson());
                //dialog.getVisualPanel().showPersonInfo(getPerson(), true);
                ((RuleBasedInteractionDialogPluginImpl)dialog.getPlugin()).notifyActivePersonChanged();
                return true;
            }
        }
        
        return false;
    }
    
    protected void convinceMercToStay() {
        PersonAPI merc = dialog.getInteractionTarget().getActivePerson();
        dialog.getInteractionTarget().setActivePerson(null);
        
        if (merc != null) {
            Misc.setMercHiredNow(merc);
            
            String key = "$mercs_leaveTimeout";
            Global.getSector().getMemoryWithoutUpdate().set(key, true, 5f + (float) Math.random() * 5f);
            merc.getMemoryWithoutUpdate().set(key, true, 35f + (float) Math.random() * 5f);
        }
        
    }
    
    protected void mercLeaves() {
        PersonAPI merc = dialog.getInteractionTarget().getActivePerson();
        dialog.getInteractionTarget().setActivePerson(null);
        
        if (merc != null) {
            FleetMemberAPI member = playerFleet.getFleetData().getMemberWithCaptain(merc);
            if (member != null) {
                member.setCaptain(null);
            }
            playerFleet.getFleetData().removeOfficer(merc);
            
            AddRemoveCommodity.addOfficerLossText(merc, text);
            
            String key = "$mercs_leaveTimeout";
            Global.getSector().getMemoryWithoutUpdate().set(key, true, 5f + (float) Math.random() * 5f);
        }
    }
 
}