← Back to branch summary

~ubuntu-branches/ubuntu/precise/triplea/precise

« back to all changes in this revision

Viewing changes to src/games/strategy/triplea/TripleAPlayer.java

  • Committer: Package Import Robot
  • Author(s): Scott Howard
  • Date: 2011-11-11 21:40:11 UTC
  • Revision ID: package-import@ubuntu.com-20111111214011-sehf2rwat36o2xqf
Tags: upstream-1.3.2.2
Import upstream version 1.3.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/games/strategy/triplea/TripleAPlayer.java
 
1
/*
 
2
 * This program is free software; you can redistribute it and/or modify
 
3
 * it under the terms of the GNU General Public License as published by
 
4
 * the Free Software Foundation; either version 2 of the License, or
 
5
 * (at your option) any later version.
 
6
 * This program is distributed in the hope that it will be useful,
 
7
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
8
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
9
 * GNU General Public License for more details.
 
10
 * You should have received a copy of the GNU General Public License
 
11
 * along with this program; if not, write to the Free Software
 
12
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
13
 */
 
14
 
 
15
/*
 
16
 * TripleAPlayer.java
 
17
 *
 
18
 * Created on November 2, 2001, 8:45 PM
 
19
 */
 
20
 
 
21
package games.strategy.triplea;
 
22
 
 
23
import games.strategy.common.player.AbstractHumanPlayer;
 
24
import games.strategy.engine.data.PlayerID;
 
25
import games.strategy.engine.data.ProductionRule;
 
26
import games.strategy.engine.data.RepairRule;
 
27
import games.strategy.engine.data.Territory;
 
28
import games.strategy.engine.data.Unit;
 
29
import games.strategy.engine.gamePlayer.IGamePlayer;
 
30
import games.strategy.net.GUID;
 
31
import games.strategy.triplea.attatchments.PlayerAttachment;
 
32
import games.strategy.triplea.attatchments.TerritoryAttachment;
 
33
import games.strategy.triplea.delegate.BidPurchaseDelegate;
 
34
import games.strategy.triplea.delegate.DiceRoll;
 
35
import games.strategy.triplea.delegate.Matches;
 
36
import games.strategy.triplea.delegate.dataObjects.BattleListing;
 
37
import games.strategy.triplea.delegate.dataObjects.CasualtyDetails;
 
38
import games.strategy.triplea.delegate.dataObjects.FightBattleDetails;
 
39
import games.strategy.triplea.delegate.dataObjects.MoveDescription;
 
40
import games.strategy.triplea.delegate.dataObjects.TechResults;
 
41
import games.strategy.triplea.delegate.dataObjects.TechRoll;
 
42
import games.strategy.triplea.delegate.remote.IAbstractPlaceDelegate;
 
43
import games.strategy.triplea.delegate.remote.IBattleDelegate;
 
44
import games.strategy.triplea.delegate.remote.IMoveDelegate;
 
45
import games.strategy.triplea.delegate.remote.IPurchaseDelegate;
 
46
import games.strategy.triplea.delegate.remote.ITechDelegate;
 
47
import games.strategy.triplea.delegate.remote.IEditDelegate;
 
48
import games.strategy.triplea.formatter.MyFormatter;
 
49
import games.strategy.triplea.player.ITripleaPlayer;
 
50
import games.strategy.triplea.ui.BattleDisplay;
 
51
import games.strategy.triplea.ui.PlaceData;
 
52
import games.strategy.triplea.ui.TripleAFrame;
 
53
import games.strategy.util.CompositeMatchAnd;
 
54
import games.strategy.util.IntegerMap;
 
55
import games.strategy.util.InverseMatch;
 
56
import games.strategy.util.Match;
 
57
 
 
58
import games.strategy.engine.data.GameData;
 
59
import java.awt.event.ActionEvent;
 
60
import java.util.ArrayList;
 
61
import java.util.Collection;
 
62
import java.util.HashMap;
 
63
import java.util.Iterator;
 
64
import java.util.List;
 
65
import java.util.Map;
 
66
import javax.swing.AbstractAction;
 
67
import javax.swing.ButtonModel;
 
68
import javax.swing.SwingUtilities;
 
69
 
 
70
/**
 
71
 * 
 
72
 * @author Sean Bridges
 
73
 * @version 1.0
 
74
 */
 
75
public class TripleAPlayer extends AbstractHumanPlayer<TripleAFrame> implements IGamePlayer, ITripleaPlayer
 
76
{
 
77
    /** Creates new TripleAPlayer */
 
78
    public TripleAPlayer(String name)
 
79
    {
 
80
        super(name);
 
81
    }
 
82
 
 
83
    public void reportError(String error)
 
84
    {
 
85
        m_ui.notifyError(error);
 
86
    }
 
87
    
 
88
    public void reportMessage(String message)
 
89
    {
 
90
        m_ui.notifyMessage(message);
 
91
    }
 
92
 
 
93
    public void start(String name)
 
94
    {
 
95
        boolean badStep = false;
 
96
 
 
97
        try 
 
98
        {
 
99
            m_ui.setEditDelegate((IEditDelegate)m_bridge.getRemote("edit"));
 
100
        }
 
101
        catch (Exception e)
 
102
        {
 
103
        }
 
104
        
 
105
        SwingUtilities.invokeLater( new Runnable() {
 
106
        
 
107
            public void run() {
 
108
                m_ui.getEditModeButtonModel().addActionListener(m_editModeAction);
 
109
                m_ui.getEditModeButtonModel().setEnabled(true);        
 
110
            }
 
111
        });
 
112
        
 
113
 
 
114
        if (name.endsWith("Bid"))
 
115
            purchase(true);
 
116
        else if (name.endsWith("Tech"))
 
117
            tech();
 
118
        else if (name.endsWith("TechActivation"))
 
119
            {} // the delegate handles everything
 
120
        else if (name.endsWith("Purchase"))
 
121
            purchase(false);
 
122
        else if (name.endsWith("Move"))
 
123
            move(name.endsWith("NonCombatMove"));
 
124
        else if (name.endsWith("Battle"))
 
125
            battle();
 
126
        else if (name.endsWith("Place"))
 
127
            place(name.indexOf("Bid") != -1);
 
128
        else if (name.endsWith("EndTurn"))
 
129
            endTurn();
 
130
        else
 
131
            badStep = true;
 
132
 
 
133
        
 
134
        SwingUtilities.invokeLater( new Runnable() {
 
135
            
 
136
            public void run() {
 
137
                m_ui.getEditModeButtonModel().setEnabled(false);
 
138
                m_ui.getEditModeButtonModel().removeActionListener(m_editModeAction);
 
139
                m_ui.setEditDelegate(null);
 
140
            }}
 
141
        );
 
142
        
 
143
        
 
144
        if (badStep)
 
145
            throw new IllegalArgumentException("Unrecognized step name:" + name);
 
146
    }
 
147
    
 
148
    private AbstractAction m_editModeAction = new AbstractAction()
 
149
    {
 
150
        public void actionPerformed(ActionEvent ae)
 
151
        {
 
152
            boolean editMode = ((ButtonModel)ae.getSource()).isSelected();
 
153
            try 
 
154
            {
 
155
                // Set edit mode
 
156
                // All GameDataChangeListeners will be notified upon success
 
157
                IEditDelegate editDelegate = (IEditDelegate) m_bridge.getRemote("edit");
 
158
                editDelegate.setEditMode(editMode);
 
159
            }
 
160
            catch (Exception e)
 
161
            {
 
162
                e.printStackTrace();
 
163
                // toggle back to previous state since setEditMode failed
 
164
                m_ui.getEditModeButtonModel().setSelected(!m_ui.getEditModeButtonModel().isSelected());
 
165
            }
 
166
        }
 
167
    };
 
168
 
 
169
    private void tech()
 
170
    {
 
171
        //can we tech?
 
172
        m_bridge.getGameData().acquireReadLock();
 
173
        try
 
174
        {
 
175
            if (m_id.getResources().getQuantity(Constants.PUS) == 0 || !isTechDevelopment(m_bridge.getGameData()))
 
176
                return;
 
177
        }
 
178
        finally 
 
179
        {
 
180
            m_bridge.getGameData().releaseReadLock();
 
181
        }
 
182
 
 
183
        TechRoll techRoll = m_ui.getTechRolls(m_id);
 
184
        if (techRoll != null)
 
185
        {
 
186
            ITechDelegate techDelegate = (ITechDelegate) m_bridge.getRemote();
 
187
            TechResults techResults = techDelegate.rollTech(
 
188
                    techRoll.getRolls(), techRoll.getTech(), techRoll.getNewTokens());
 
189
 
 
190
            if (techResults.isError())
 
191
            {
 
192
                m_ui.notifyError(techResults.getErrorString());
 
193
                tech();
 
194
            } else
 
195
                m_ui.notifyTechResults(techResults);
 
196
        }
 
197
    }
 
198
 
 
199
    private void move(boolean nonCombat)
 
200
    {
 
201
        if (!m_scrambledUnitsReturned && nonCombat && getScramble_Rules_In_Effect())
 
202
        {
 
203
                m_scrambledUnitsReturned = true;
 
204
                CompositeMatchAnd<Unit> unitWasScrambled = new CompositeMatchAnd<Unit>();
 
205
                unitWasScrambled.add(Matches.UnitWasScrambled);
 
206
 
 
207
                Collection<Unit> scrambledUnits = new ArrayList<Unit>();
 
208
 
 
209
                //territories
 
210
                for(Territory t : m_bridge.getGameData().getMap().getTerritories())
 
211
                {
 
212
                        scrambledUnits.addAll(t.getUnits().getMatches(unitWasScrambled));
 
213
                }
 
214
 
 
215
                //units were scrambled, move them
 
216
                if(!scrambledUnits.isEmpty())
 
217
                        returnScrambledUnits(scrambledUnits);
 
218
        }
 
219
        
 
220
        if (!hasUnitsThatCanMove(nonCombat))
 
221
            return;
 
222
 
 
223
        MoveDescription moveDescription = m_ui.getMove(m_id, m_bridge, nonCombat);
 
224
        if (moveDescription == null)
 
225
        {
 
226
            if (nonCombat)
 
227
            {
 
228
                if(!canAirLand(true, m_id))
 
229
                    move(nonCombat);
 
230
            }
 
231
            else
 
232
            {           
 
233
                if(canUnitsFight())
 
234
                        move(nonCombat);
 
235
            }
 
236
            return;
 
237
        }
 
238
 
 
239
        IMoveDelegate moveDel = (IMoveDelegate) m_bridge.getRemote();
 
240
        String error = moveDel.move(moveDescription.getUnits(), moveDescription.getRoute(), moveDescription.getTransportsThatCanBeLoaded());
 
241
        
 
242
        if (error != null )
 
243
            m_ui.notifyError(error);
 
244
        move(nonCombat);        
 
245
    }
 
246
    
 
247
    private void returnScrambledUnits(Collection<Unit> scrambledUnits)
 
248
    {   
 
249
        // find only players with units in the collection
 
250
        Collection <PlayerID> players = new ArrayList<PlayerID>();
 
251
        for(Unit unit : scrambledUnits)
 
252
        {
 
253
                if(!players.contains(unit.getOwner()))
 
254
                        players.add(unit.getOwner());
 
255
        }
 
256
 
 
257
        for(PlayerID player : players)
 
258
        {
 
259
                MoveDescription moveDescription = m_ui.getMove(player, m_bridge, true);
 
260
                 if (moveDescription == null)
 
261
                {
 
262
                         if(!canAirLand(true, player))
 
263
                                 move(true);
 
264
                         return;
 
265
                }
 
266
 
 
267
                 IMoveDelegate moveDel = (IMoveDelegate) m_bridge.getRemote();
 
268
                 String error = moveDel.move(moveDescription.getUnits(), moveDescription.getRoute());
 
269
 
 
270
                 if (error != null )
 
271
                         m_ui.notifyError(error);
 
272
 
 
273
                 //get just the player's units
 
274
                 Collection <Unit> playerUnits = new ArrayList<Unit>();
 
275
                 playerUnits.addAll(Match.getMatches(scrambledUnits, Matches.unitIsOwnedBy(player)));
 
276
 
 
277
                 //if they haven't all been moved- do it again
 
278
                 if(Match.someMatch(playerUnits, Matches.UnitWasScrambled))
 
279
                 {
 
280
                         returnScrambledUnits(scrambledUnits);
 
281
                 }
 
282
        }
 
283
        
 
284
        return;
 
285
    }
 
286
    
 
287
    private boolean canAirLand(boolean movePhase, PlayerID player)
 
288
    {
 
289
        
 
290
        Collection<Territory> airCantLand;
 
291
        if(movePhase)
 
292
            airCantLand = ((IMoveDelegate) m_bridge.getRemote()).getTerritoriesWhereAirCantLand(player);
 
293
        else
 
294
            airCantLand = ((IAbstractPlaceDelegate) m_bridge.getRemote()).getTerritoriesWhereAirCantLand();
 
295
        
 
296
        if (airCantLand.isEmpty())
 
297
            return true;
 
298
        else
 
299
        {
 
300
            StringBuilder buf = new StringBuilder(
 
301
                    "Air in following territories cant land:");
 
302
            Iterator<Territory> iter = airCantLand.iterator();
 
303
            while (iter.hasNext())
 
304
            {
 
305
                buf.append(((Territory) iter.next()).getName());
 
306
                buf.append(" ");
 
307
            }
 
308
            if (!m_ui.getOKToLetAirDie(m_id, buf.toString(), movePhase))
 
309
                return false;
 
310
            return true;
 
311
        }
 
312
    }
 
313
    
 
314
    private boolean canUnitsFight()
 
315
    {        
 
316
        Collection<Territory> unitsCantFight;
 
317
        
 
318
        unitsCantFight = ((IMoveDelegate) m_bridge.getRemote()).getTerritoriesWhereUnitsCantFight();
 
319
        
 
320
        
 
321
        if (unitsCantFight.isEmpty())
 
322
            return false;
 
323
        else
 
324
        {
 
325
            StringBuilder buf = new StringBuilder(
 
326
                    "Units in the following territories will die:");
 
327
            Iterator<Territory> iter = unitsCantFight.iterator();
 
328
            while (iter.hasNext())
 
329
            {
 
330
                buf.append(((Territory) iter.next()).getName());
 
331
                buf.append(" ");
 
332
            }
 
333
            if (m_ui.getOKToLetUnitsDie(m_id, buf.toString(), true))
 
334
                return false;
 
335
            return true;
 
336
        }
 
337
    }
 
338
    private boolean hasUnitsThatCanMove(boolean nonCom)
 
339
    {
 
340
        CompositeMatchAnd<Unit> moveableUnitOwnedByMe = new CompositeMatchAnd<Unit>();
 
341
        moveableUnitOwnedByMe.add(Matches.unitIsOwnedBy(m_id));
 
342
        moveableUnitOwnedByMe.add(Matches.UnitIsNotStatic(m_id));
 
343
        //if not non combat, can not move aa units
 
344
        if(!nonCom)
 
345
            moveableUnitOwnedByMe.add(new InverseMatch<Unit>(Matches.UnitIsAAorIsAAmovement));
 
346
 
 
347
        m_bridge.getGameData().acquireReadLock();
 
348
        try
 
349
        {
 
350
            Iterator<Territory> territoryIter = m_bridge.getGameData().getMap()
 
351
                    .getTerritories().iterator();
 
352
            while (territoryIter.hasNext())
 
353
            {
 
354
                Territory item = (Territory) territoryIter.next();
 
355
                if (item.getUnits().someMatch(moveableUnitOwnedByMe))
 
356
                {
 
357
                    return true;
 
358
                }
 
359
            }
 
360
            return false;
 
361
        }
 
362
        finally 
 
363
        {
 
364
            m_bridge.getGameData().releaseReadLock();
 
365
        }
 
366
 
 
367
    }
 
368
 
 
369
    private void purchase(boolean bid)
 
370
    {
 
371
        if (bid)
 
372
        {
 
373
            if(!BidPurchaseDelegate.doesPlayerHaveBid(m_bridge.getGameData(), m_id))
 
374
                return;
 
375
        }
 
376
        
 
377
        // NoPUPurchaseDelegate will run first, before this section. After running, the engine will wait for the player by coming here. Exit if we are a No PU delegate purchase
 
378
        if (this.m_bridge.getStepName().endsWith("NoPUPurchase"))
 
379
                return;
 
380
        
 
381
        //we have no production frontier
 
382
        else if(m_id.getProductionFrontier() == null || m_id.getProductionFrontier().getRules().isEmpty())
 
383
        {
 
384
            return;
 
385
        }         
 
386
        else
 
387
        {
 
388
            //if my capital is captured, I can't produce, but I may have PUs if I captured someone else's capital
 
389
                List<Territory> capitalsListOriginal = new ArrayList<Territory>(TerritoryAttachment.getAllCapitals(m_id, m_bridge.getGameData()));
 
390
                List<Territory> capitalsListOwned = new ArrayList<Territory>(TerritoryAttachment.getAllCurrentlyOwnedCapitals(m_id, m_bridge.getGameData()));
 
391
                PlayerAttachment pa = PlayerAttachment.get(m_id);
 
392
                if ((!capitalsListOriginal.isEmpty() && capitalsListOwned.isEmpty()) || (pa != null && pa.getRetainCapitalProduceNumber() > capitalsListOwned.size()))
 
393
                        return;
 
394
            
 
395
            int minPUsNeededToBuild = Integer.MAX_VALUE;
 
396
            m_bridge.getGameData().acquireReadLock();
 
397
            try
 
398
            {
 
399
                Iterator<ProductionRule> prodRules = m_id.getProductionFrontier().getRules().iterator();
 
400
                while(prodRules.hasNext())
 
401
                {
 
402
                    ProductionRule rule = (ProductionRule) prodRules.next();
 
403
                    minPUsNeededToBuild = Math.min(rule.getCosts().getInt(m_bridge.getGameData().getResourceList().getResource(Constants.PUS)), minPUsNeededToBuild);
 
404
                }
 
405
                     
 
406
                if(m_id.getRepairFrontier() != null)
 
407
                {
 
408
                    Iterator<RepairRule> repairRules = m_id.getRepairFrontier().getRules().iterator();
 
409
                    while(repairRules.hasNext())
 
410
                    {
 
411
                        RepairRule rule = (RepairRule) repairRules.next();
 
412
                        minPUsNeededToBuild = Math.min(rule.getCosts().getInt(m_bridge.getGameData().getResourceList().getResource(Constants.PUS)), minPUsNeededToBuild);
 
413
                    }
 
414
                }
 
415
                
 
416
                //can we buy anything
 
417
                if (m_id.getResources().getQuantity(Constants.PUS) < minPUsNeededToBuild)
 
418
                    return;
 
419
            }
 
420
            finally
 
421
            {
 
422
                m_bridge.getGameData().releaseReadLock();
 
423
            }
 
424
        }
 
425
 
 
426
      //Check if any factories need to be repaired
 
427
        String error = null;
 
428
                IPurchaseDelegate purchaseDel = (IPurchaseDelegate) m_bridge.getRemote();
 
429
                
 
430
        if(isSBRAffectsUnitProduction(m_bridge.getGameData()))
 
431
        {
 
432
                GameData data = m_bridge.getGameData();
 
433
                Collection<Territory> bombedTerrs = new ArrayList<Territory>();
 
434
                for(Territory t : Match.getMatches(data.getMap().getTerritories(), Matches.territoryHasOwnedIsFactoryOrCanProduceUnits(data, m_id))) 
 
435
                {
 
436
                        TerritoryAttachment ta = TerritoryAttachment.get(t);
 
437
                        //changed this to > from !=
 
438
                        if(ta.getProduction() > ta.getUnitProduction())
 
439
                        {
 
440
                                bombedTerrs.add(t);
 
441
                        }
 
442
                }
 
443
                
 
444
                Collection<Unit> damagedUnits = new ArrayList<Unit>();
 
445
                Match<Unit> myFactories = new CompositeMatchAnd<Unit>(Matches.unitIsOwnedBy(m_id), Matches.UnitIsFactoryOrCanBeDamaged);
 
446
                
 
447
                for (Territory t : bombedTerrs)
 
448
                {
 
449
                        damagedUnits.addAll(Match.getMatches(t.getUnits().getUnits(), myFactories));
 
450
                }
 
451
                
 
452
                if(bombedTerrs.size() > 0 && damagedUnits.size() > 0)
 
453
                {
 
454
                    HashMap<Unit, IntegerMap<RepairRule>> repair = m_ui.getRepair(m_id, bid);
 
455
                        if (repair != null)
 
456
                        {
 
457
                                purchaseDel = (IPurchaseDelegate) m_bridge.getRemote();
 
458
                                error = purchaseDel.purchaseRepair(repair);
 
459
                                if (error != null)
 
460
                                {
 
461
                                        m_ui.notifyError(error);
 
462
                                        //dont give up, keep going
 
463
                                        purchase(bid);
 
464
 
 
465
                                }
 
466
                        }
 
467
                }
 
468
        }
 
469
        else if (isDamageFromBombingDoneToUnitsInsteadOfTerritories(m_bridge.getGameData()))
 
470
        {
 
471
                GameData data = m_bridge.getGameData();
 
472
                Match<Unit> myDamaged = new CompositeMatchAnd<Unit>(Matches.unitIsOwnedBy(m_id), Matches.UnitHasSomeUnitDamage());
 
473
                Collection<Unit> damagedUnits = new ArrayList<Unit>();
 
474
                for (Territory t : data.getMap().getTerritories())
 
475
                {
 
476
                        damagedUnits.addAll(Match.getMatches(t.getUnits().getUnits(), myDamaged));
 
477
                }
 
478
                
 
479
                if(damagedUnits.size() > 0)
 
480
                {
 
481
                    HashMap<Unit, IntegerMap<RepairRule>> repair = m_ui.getRepair(m_id, bid);
 
482
                        if (repair != null)
 
483
                        {
 
484
                                purchaseDel = (IPurchaseDelegate) m_bridge.getRemote(); //TODO: veq fix
 
485
                                error = purchaseDel.purchaseRepair(repair);
 
486
                                if (error != null)
 
487
                                {
 
488
                                        m_ui.notifyError(error);
 
489
                                        //dont give up, keep going
 
490
                                        purchase(bid);
 
491
                                }
 
492
                        }
 
493
                }
 
494
        }
 
495
        
 
496
        IntegerMap<ProductionRule> prod = m_ui.getProduction(m_id, bid);
 
497
        if (prod == null)
 
498
            return;
 
499
        purchaseDel = (IPurchaseDelegate) m_bridge.getRemote();
 
500
        error = purchaseDel.purchase(prod);
 
501
        
 
502
        if (error != null)
 
503
        {
 
504
            m_ui.notifyError(error);
 
505
            //dont give up, keep going
 
506
            purchase(bid);
 
507
 
 
508
        }
 
509
        return;
 
510
    }
 
511
 
 
512
    private void battle()
 
513
    {
 
514
        while (true)
 
515
        {
 
516
            IBattleDelegate battleDel = (IBattleDelegate) m_bridge.getRemote();
 
517
            BattleListing battles = battleDel.getBattles();
 
518
           
 
519
                
 
520
                if (battles.isEmpty())
 
521
                {
 
522
                    return;
 
523
                }
 
524
                
 
525
                FightBattleDetails details = m_ui.getBattle(m_id, battles
 
526
                        .getBattles(), battles.getStrategicRaids());
 
527
                
 
528
                if(m_bridge.isGameOver())
 
529
                    return;
 
530
                
 
531
                String error = battleDel.fightBattle(details.getWhere(), details.isBombingRaid());
 
532
 
 
533
                if(error != null)
 
534
                        m_ui.notifyError(error);
 
535
        }
 
536
    }
 
537
 
 
538
    private void place(boolean bid)
 
539
    {
 
540
        IAbstractPlaceDelegate placeDel = (IAbstractPlaceDelegate) m_bridge.getRemote();
 
541
        //nothing to place
 
542
        //nothing placed
 
543
        if (m_id.getUnits().size() == 0 && placeDel.getPlacementsMade() == 0)
 
544
            return;
 
545
        
 
546
        while(true)
 
547
        {
 
548
            PlaceData data = m_ui.waitForPlace(m_id ,bid, m_bridge);
 
549
            if(data == null)
 
550
            {
 
551
                //this only happens in lhtr rules
 
552
                if(canAirLand(false, m_id))
 
553
                    return;
 
554
                else
 
555
                    continue;
 
556
            }
 
557
            
 
558
            String error = placeDel.placeUnits(data.getUnits(), data.getAt());
 
559
            if(error != null)
 
560
                m_ui.notifyError(error);
 
561
        }
 
562
    }
 
563
 
 
564
    private void endTurn()
 
565
    {
 
566
        m_ui.waitForEndTurn(m_id, m_bridge);
 
567
    }
 
568
    
 
569
 
 
570
    /* 
 
571
     * @see games.strategy.triplea.player.ITripleaPlayer#selectCasualties(java.lang.String, java.util.Collection, java.util.Map, int, java.lang.String, games.strategy.triplea.delegate.DiceRoll, games.strategy.engine.data.PlayerID, java.util.List)
 
572
     */
 
573
 
 
574
    public CasualtyDetails selectCasualties(Collection<Unit> selectFrom, Map<Unit, Collection<Unit>> dependents, int count, String message, DiceRoll dice, PlayerID hit, List<Unit> defaultCasualties, GUID battleID)
 
575
    {
 
576
        return m_ui.getBattlePanel().getCasualties(selectFrom, dependents, count, message, dice,hit, defaultCasualties, battleID);
 
577
    }
 
578
 
 
579
    /* 
 
580
     * @see games.strategy.triplea.player.ITripleaPlayer#selectFixedDice(int, int, boolean, java.lang.String)
 
581
     */
 
582
    public int[] selectFixedDice(int numDice, int hitAt, boolean hitOnlyIfEquals, String title, int diceSides)
 
583
    {
 
584
        return m_ui.selectFixedDice(numDice, hitAt, hitOnlyIfEquals, title, diceSides);
 
585
    }
 
586
 
 
587
    /* 
 
588
     * @see games.strategy.triplea.player.ITripleaPlayer#selectBombardingTerritory(games.strategy.engine.data.Unit, games.strategy.engine.data.Territory, java.util.Collection, boolean)
 
589
     */
 
590
    public Territory selectBombardingTerritory(Unit unit, Territory unitTerritory, Collection<Territory>  territories, boolean noneAvailable)
 
591
    {
 
592
        return m_ui.getBattlePanel().getBombardment(unit, unitTerritory,  territories, noneAvailable);
 
593
    }
 
594
 
 
595
    /* 
 
596
     * Ask if the player wants to attack subs
 
597
     */
 
598
    public boolean selectAttackSubs(Territory unitTerritory)
 
599
    {
 
600
        return m_ui.getBattlePanel().getAttackSubs(unitTerritory);
 
601
    }
 
602
 
 
603
    /* 
 
604
     * Ask if the player wants to attack transports
 
605
     */
 
606
    public boolean selectAttackTransports(Territory unitTerritory)
 
607
    {
 
608
        return m_ui.getBattlePanel().getAttackTransports(unitTerritory);
 
609
    }
 
610
 
 
611
    /* 
 
612
     * Ask if the player wants to attack units
 
613
     */
 
614
    public boolean selectAttackUnits(Territory unitTerritory)
 
615
    {
 
616
        return m_ui.getBattlePanel().getAttackUnits(unitTerritory);
 
617
    }
 
618
    
 
619
    /* 
 
620
     * Ask if the player wants to shore bombard
 
621
     */
 
622
    public boolean selectShoreBombard(Territory unitTerritory)
 
623
    {
 
624
        return m_ui.getBattlePanel().getShoreBombard(unitTerritory);
 
625
    }
 
626
    
 
627
    /* 
 
628
     * @see games.strategy.triplea.player.ITripleaPlayer#shouldBomberBomb(games.strategy.engine.data.Territory)
 
629
     */
 
630
    public boolean shouldBomberBomb(Territory territory)
 
631
    {
 
632
        return m_ui.getStrategicBombingRaid(territory);
 
633
       
 
634
    } 
 
635
    
 
636
    /* 
 
637
     * @see games.strategy.triplea.player.ITripleaPlayer#shouldBomberBomb(games.strategy.engine.data.Territory)
 
638
     */
 
639
    public Unit whatShouldBomberBomb(Territory territory, Collection<Unit> units)
 
640
    {
 
641
        return m_ui.getStrategicBombingRaidTarget(territory, units);
 
642
       
 
643
    } 
 
644
    
 
645
    public Territory whereShouldRocketsAttack(Collection<Territory> candidates, Territory from)
 
646
    {
 
647
        return m_ui.getRocketAttack(candidates, from);
 
648
     }
 
649
 
 
650
    /* (non-Javadoc)
 
651
     * @see games.strategy.triplea.player.ITripleaPlayer#getNumberOfFightersToMoveToNewCarrier(java.util.Collection, games.strategy.engine.data.Territory)
 
652
     */
 
653
    public Collection<Unit> getNumberOfFightersToMoveToNewCarrier(Collection<Unit> fightersThatCanBeMoved, Territory from)
 
654
    {
 
655
        return m_ui.moveFightersToCarrier(fightersThatCanBeMoved, from);
 
656
    }
 
657
 
 
658
    /*
 
659
     * @see games.strategy.triplea.player.ITripleaPlayer#selectTerritoryForAirToLand(java.util.Collection, java.lang.String)
 
660
     */
 
661
    public Territory selectTerritoryForAirToLand(Collection<Territory> candidates)
 
662
    {
 
663
        return m_ui.selectTerritoryForAirToLand(candidates);
 
664
    }
 
665
 
 
666
 
 
667
    /* (non-Javadoc)
 
668
     * @see games.strategy.triplea.player.ITripleaPlayer#confirmMoveInFaceOfAA(java.util.Collection)
 
669
     */
 
670
    public boolean confirmMoveInFaceOfAA(Collection<Territory> aaFiringTerritories)
 
671
    {
 
672
        String question = "AA guns will fire in " + MyFormatter.territoriesToText(aaFiringTerritories, "and") + ", do you still want to move?";
 
673
        return m_ui.getOK(question);
 
674
        
 
675
    }
 
676
 
 
677
    public boolean confirmMoveKamikaze()
 
678
    {
 
679
        String question = "Not all air units in destination territory can land, do you still want to move?";
 
680
        return m_ui.getOK(question);
 
681
    }
 
682
 
 
683
    public boolean confirmMoveHariKari()
 
684
    {
 
685
        String question = "All units in destination territory will automatically die, do you still want to move?";
 
686
        return m_ui.getOK(question);
 
687
    }
 
688
 
 
689
    /* (non-Javadoc)
 
690
     * @see games.strategy.triplea.player.ITripleaPlayer#retreatQuery(games.strategy.net.GUID, boolean, java.util.Collection, java.lang.String, java.lang.String)
 
691
     */
 
692
    public Territory retreatQuery(GUID battleID, boolean submerge, Collection<Territory> possibleTerritories, String message)
 
693
    {
 
694
        return m_ui.getBattlePanel().getRetreat(battleID, message, possibleTerritories,submerge);
 
695
    }
 
696
 
 
697
    /* (non-Javadoc)
 
698
     * @see games.strategy.triplea.player.ITripleaPlayer#scrambleQuery(games.strategy.net.GUID, java.util.Collection, java.lang.String, java.lang.String)
 
699
     */
 
700
    public Collection<Unit> scrambleQuery(GUID battleID, Collection<Territory> possibleTerritories, String message)
 
701
    {
 
702
        return m_ui.getBattlePanel().getScramble(m_bridge, battleID, message, possibleTerritories);
 
703
    }
 
704
    
 
705
    public void confirmEnemyCasualties(GUID battleId, String message, PlayerID hitPlayer)
 
706
    {
 
707
        //no need, we have already confirmed since we are firing player
 
708
        if(m_ui.playing(hitPlayer))
 
709
            return;
 
710
        //we dont want to confirm enemy casualties
 
711
        if(!BattleDisplay.getShowEnemyCasualtyNotification())
 
712
            return;
 
713
        
 
714
        m_ui.getBattlePanel().confirmCasualties(battleId, message);
 
715
    }
 
716
 
 
717
    public void confirmOwnCasualties(GUID battleId, String message)
 
718
    {
 
719
        m_ui.getBattlePanel().confirmCasualties(battleId, message);
 
720
    }   
 
721
 
 
722
    public final boolean isSBRAffectsUnitProduction(GameData data)
 
723
    {
 
724
        return games.strategy.triplea.Properties.getSBRAffectsUnitProduction(data);
 
725
    }
 
726
 
 
727
    public final boolean isDamageFromBombingDoneToUnitsInsteadOfTerritories(GameData data)
 
728
    {
 
729
        return games.strategy.triplea.Properties.getDamageFromBombingDoneToUnitsInsteadOfTerritories(data);
 
730
    }
 
731
 
 
732
    private static boolean isTechDevelopment(GameData data)
 
733
    {
 
734
        return games.strategy.triplea.Properties.getTechDevelopment(data);
 
735
    }
 
736
 
 
737
    private boolean getScramble_Rules_In_Effect()
 
738
    {
 
739
        return games.strategy.triplea.Properties.getScramble_Rules_In_Effect(m_bridge.getGameData());
 
740
    }
 
741
}
 
742
 
 
743
 
 
744
 
 
745
 
 
746
 
 
747
 
 
748
 
 
749