Source code

001package com.fs.starfarer.api.impl.campaign.intel.group;
002
003import java.util.LinkedHashSet;
004import java.util.Random;
005import java.util.Set;
006
007import com.fs.starfarer.api.Global;
008import com.fs.starfarer.api.campaign.CampaignFleetAPI;
009import com.fs.starfarer.api.campaign.InteractionDialogAPI;
010import com.fs.starfarer.api.campaign.SectorEntityToken;
011import com.fs.starfarer.api.campaign.StarSystemAPI;
012import com.fs.starfarer.api.campaign.econ.Industry;
013import com.fs.starfarer.api.campaign.econ.MarketAPI;
014import com.fs.starfarer.api.campaign.rules.MemoryAPI;
015import com.fs.starfarer.api.impl.campaign.ids.Factions;
016import com.fs.starfarer.api.impl.campaign.ids.Industries;
017import com.fs.starfarer.api.impl.campaign.ids.MemFlags;
018import com.fs.starfarer.api.impl.campaign.ids.Tags;
019import com.fs.starfarer.api.impl.campaign.intel.events.TriTachyonHostileActivityFactor;
020import com.fs.starfarer.api.impl.campaign.intel.events.ttcr.TTCRMercenariesBribedFactor;
021import com.fs.starfarer.api.impl.campaign.intel.events.ttcr.TriTachyonCommerceRaiding;
022import com.fs.starfarer.api.impl.campaign.intel.group.FGRaidAction.FGRaidType;
023import com.fs.starfarer.api.ui.SectorMapAPI;
024import com.fs.starfarer.api.util.IntervalUtil;
025import com.fs.starfarer.api.util.Misc;
026
027
028
029public class TTMercenaryReversedAttack extends GenericRaidFGI  {
030
031        public static final String TTMAR_FLEET = "$TTMAR_fleet";
032        public static final String TTMAR_COMMAND = "$TTMAR_command";
033        
034        public static String KEY = "$TTMAR_ref";
035        public static TTMercenaryReversedAttack get() {
036                return (TTMercenaryReversedAttack) Global.getSector().getMemoryWithoutUpdate().get(KEY);
037        }
038        
039        
040        
041        
042        public static void sendReversedAttack(InteractionDialogAPI dialog) {
043                TTMercenaryAttack attack = TTMercenaryAttack.get();
044                if (attack == null || attack.isEnding()) return;
045                
046                Random random = new Random();
047                
048                StarSystemAPI target = TriTachyonHostileActivityFactor.getPrimaryTriTachyonSystem();
049                if (target == null) return;
050                
051                GenericRaidParams params = new GenericRaidParams(new Random(), false);
052                //params.makeFleetsHostile = true; // irrelevant since fleets already spawned
053                
054                //params.source = attack.params.source;
055                
056                CampaignFleetAPI pf = Global.getSector().getPlayerFleet();
057                SectorEntityToken origin = pf.getContainingLocation().createToken(pf.getLocation());
058                
059                MarketAPI fake = Global.getFactory().createMarket("fake", "an independent world", 5);
060                fake.setFactionId(Factions.INDEPENDENT);
061                fake.setPrimaryEntity(origin);
062                origin.setMarket(fake);
063                params.source = fake;
064                
065                params.prepDays = 0f;
066                params.payloadDays = 27f + 7f * random.nextFloat();
067                
068                params.raidParams.where = target;
069                params.raidParams.type = FGRaidType.SEQUENTIAL;
070                
071                Set<String> disrupt = new LinkedHashSet<String>();
072                for (MarketAPI market : Misc.getMarketsInLocation(target, Factions.TRITACHYON)) {
073                        params.raidParams.allowedTargets.add(market);
074                        params.raidParams.allowNonHostileTargets = true;
075                        for (Industry ind : market.getIndustries()) {
076                                if (ind.getSpec().hasTag(Industries.TAG_UNRAIDABLE)) continue;
077                                disrupt.add(ind.getId());
078                        }
079                }
080                
081                params.raidParams.disrupt.addAll(disrupt);
082                params.raidParams.raidsPerColony = Math.min(disrupt.size(), 4);
083                if (disrupt.isEmpty()) {
084                        params.raidParams.raidsPerColony = 2;
085                }
086                
087                if (params.raidParams.allowedTargets.isEmpty()) {
088                        return;
089                }
090                
091                params.factionId = Factions.INDEPENDENT;
092
093                
094                TTMercenaryReversedAttack reverse = new TTMercenaryReversedAttack(params);
095                
096//              CampaignFleetAPI pf = Global.getSector().getPlayerFleet();
097//              SectorEntityToken origin = pf.getContainingLocation().createToken(pf.getLocation());
098//              reverse.setOrigin(origin);
099                
100                
101                reverse.setSpawnedFleets(true);
102                reverse.setDoIncrementalSpawn(false);
103                reverse.getFleets().addAll(attack.getFleets());
104                reverse.setTotalFPSpawned(attack.getTotalFPSpawned());
105                
106                reverse.setApproximateNumberOfFleets(attack.getApproximateNumberOfFleets());
107                
108                reverse.getRoute().setExtra(attack.getRoute().getExtra());
109                
110                // the raid "source" may be a tritach market
111                // so, make the fleets scatter/return to their individual sourceMarket instead 
112                reverse.removeAction(GenericRaidFGI.RETURN_ACTION);
113                
114                attack.finish(false);
115                attack.getFleets().clear();
116                attack.endImmediately();
117                
118                String reasonTTMA = "TTMA";
119                String reasonTTMAR = "TTMAR";
120                for (CampaignFleetAPI fleet : reverse.getFleets()) {
121                        MemoryAPI mem = fleet.getMemoryWithoutUpdate();
122                        fleet.clearAssignments();
123                        mem.unset(Misc.FLEET_RETURNING_TO_DESPAWN);
124                        
125                        mem.set(TTMAR_FLEET, true);
126                        if (mem.getBoolean(TTMercenaryAttack.TTMA_COMMAND)) {
127                                mem.set(TTMAR_COMMAND, true);
128                        }
129                        
130                        mem.unset(TTMercenaryAttack.TTMA_COMMAND);
131                        mem.unset(TTMercenaryAttack.TTMA_FLEET);
132                        
133                        Misc.makeNonHostileToFaction(fleet, Factions.DIKTAT, false, -1);
134                        Misc.makeNonHostileToFaction(fleet, Factions.TRITACHYON, false, -1);
135                        
136                        
137                        Misc.setFlagWithReason(mem, MemFlags.MEMORY_KEY_MAKE_HOSTILE,
138                                                        reasonTTMA, false, -1f);
139                        Misc.setFlagWithReason(mem, MemFlags.MEMORY_KEY_MAKE_NON_HOSTILE,
140                                                        reasonTTMAR, true, -1f);
141                }
142                
143
144                // not player targeted, so needs to be "important" so the player gets updates
145                reverse.setImportant(true);
146                
147                Global.getSector().getIntelManager().addIntel(reverse, false, dialog.getTextPanel());
148                
149                TriTachyonCommerceRaiding.addFactorCreateIfNecessary(new TTCRMercenariesBribedFactor(), dialog);
150        }
151        
152        
153        
154        protected IntervalUtil interval = new IntervalUtil(0.1f, 0.3f);
155        
156        
157        public TTMercenaryReversedAttack(GenericRaidParams params) {
158                super(params);
159                
160                Global.getSector().getMemoryWithoutUpdate().set(KEY, this);
161        }
162        
163        @Override
164        protected void notifyEnding() {
165                super.notifyEnding();
166                
167                Global.getSector().getMemoryWithoutUpdate().unset(KEY);
168        }
169        
170        @Override
171        protected void notifyEnded() {
172                super.notifyEnded();
173        }
174        
175
176        @Override
177        public String getNoun() {
178                return "mercenary attack";
179        }
180
181        @Override
182        public String getForcesNoun() {
183                return super.getForcesNoun();
184        }
185
186
187        @Override
188        public String getBaseName() {
189                return "Mercenary Counter-raid";
190        }
191
192        @Override
193        public void abort() {
194                if (!isAborted()) {
195                        for (CampaignFleetAPI curr : getFleets()) {
196                                curr.getMemoryWithoutUpdate().unset(TTMAR_FLEET);
197                        }
198                }
199                super.abort();
200        }
201        
202        
203        @Override
204        public void advance(float amount) {
205                super.advance(amount);
206
207                float days = Misc.getDays(amount);
208                interval.advance(days);
209                
210                if (interval.intervalElapsed()) {
211                        if (isCurrent(PAYLOAD_ACTION)) {
212                                for (CampaignFleetAPI curr : getFleets()) {
213                                        Misc.makeHostileToFaction(curr, Factions.TRITACHYON, 1f);
214                                }
215                        }
216                }
217        }
218
219        @Override
220        public Set<String> getIntelTags(SectorMapAPI map) {
221                Set<String> tags = super.getIntelTags(map);
222                tags.remove(Tags.INTEL_COLONIES);
223                return tags;
224        }
225
226        
227}
228
229
230
231