Class Client

  • All Implemented Interfaces:
    IClient, IOracle, OptionObjectProvider, IVariant

    public final class Client
    extends java.lang.Object
    implements IClient, IOracle, IVariant, OptionObjectProvider
    Lives on the client side and handles all communication with the server. It talks to the Server via the network protocol and to Client side classes locally, but to all GUI related classes it should only communicate via ClientGUI class. There is one client per player. TODO Handle GUI related issues purely via ClientGUI TODO All GUI classes should talk to the server purely through ClientGUI which handles it via the Client. TODO the logic for the battles could probably be separated from the rest of this code. At the moment the battle logic seems to bounce back and forth between BattleBoard (which is really a GUI class) and this class. TODO this class also has the functionality of a GameClientSide class, which should be separated and ideally moved up into the Game class. The whole IOracle interface is part of that. One approach would be moving code from GameServerSide up into Game and then reuse it here in the matching methods, then inlining it into the calling code. Another one would be creating the GameClientSide for now and relocating code there. ==> Clemens march 2009: I started the GameClientSide approach :)
    Author:
    David Ripton, Romain Dolbeau
    • Field Detail

      • LOGGER

        private static final java.util.logging.Logger LOGGER
      • server

        private IServer server
        This "server" is the access to the connector object which actually acts for us as server. Right now this is always a SocketClientThread as deputy (relay) which forwards everything that we do/tell, to the Server. Perhaps one day this could either be a SocketConnection or e.g. a Queue type of connection for local Clients...
      • connection

        private IServerConnection connection
        The object that actually handles the physical server communication for this client. Issues related to set up and tear down of the connection are handled via this access to the (right now) SocketClientThread.
      • resourceLoader

        private final ResourceLoader resourceLoader
        A first start to get rid of the static-access-everywhere to ResourceLoader. ResourceLoader is used to "load" images, variant files, readme files physically (from disk, or from remote file server thread).
      • failed

        private final boolean failed
        Client constructor sets this to true if something goes wrong with the SocketClientThread initialization. I wanted to avoid have the Client constructor throw an exception, because that caused problems in Java 1.4 with a "created but not run thread" which was then never cleaned up and thus JVM did not exit by itself. TODO perhaps that is now fixed in Java 1.5 ? I plan to change the whole "when/how SCT is created" soon anyway...
        See Also:
        Constant Field Values
      • replayOngoing

        private boolean replayOngoing
        Replay during load of a saved game is ongoing. Client must NOT react (not even redraw) on any of those messages, they are mostly sent to rebuild the predict split data.
      • redoOngoing

        private boolean redoOngoing
        Redo of the events since last commit phase is ongoing. Needed right now only for "if redo ends, set flag to prevent the setupXxxxxPhase methods to clear the undo stack.
      • gui

        private final IClientGUI gui
        This can be an actual ClientGUI, or a NullClientGUI (which does simply nothing, so that we don't need to check for null everywhere).
      • options

        private final Options options
      • playersNotInitialized

        private boolean playersNotInitialized
        At first time we get "all player info", they are created; at all later calls just update them. So this flag here tells us whether it's the first time (=true) or not any more (=false).
      • owningPlayer

        private PlayerClientSide owningPlayer
        Player who owns this client. TODO should be final but can't be until the constructor gets all the data needed
      • playerAlive

        private boolean playerAlive
      • color

        private PlayerColor color
        Starting marker color of player who owns this client. TODO most likely redundant with owningPlayer.getColor()
      • ai

        private final AI ai
      • localServer

        private final Server localServer
      • spectator

        private final boolean spectator
      • internalSpectator

        private final boolean internalSpectator
        This client is the very special internal spectator with the name as defined in Constants. The idea of this internal spectator is: it can run in standby in any game, e.g. also on the public server, and detect discrepancies between local state and updateCreatureCount or playerInfo from Server. This is part of the work, to replace "all details need to be broadcasted all the time" with "Client side does the bookkeeping autonomously; so for quite a while it would do bookkeeping and the updates are still sent but just for checking, and any discrepancy detected can/should be fixed.
      • MAX_RECONNECT_ATTEMPTS

        private static final int MAX_RECONNECT_ATTEMPTS
        See Also:
        Constant Field Values
      • RECONNECT_RETRY_INTERVAL

        private static final int RECONNECT_RETRY_INTERVAL
        See Also:
        Constant Field Values
      • tookMulligan

        private boolean tookMulligan
      • numSplitsThisTurn

        private int numSplitsThisTurn
      • delay

        private int delay
      • bestMoveOrder

        private java.util.List<CritterMove> bestMoveOrder
        For battle AI.
      • failedBattleMoves

        private java.util.List<CritterMove> failedBattleMoves
      • recruitReservations

        private final java.util.Hashtable<CreatureType,​java.lang.Integer> recruitReservations
      • gotDisposeAlready

        private boolean gotDisposeAlready
        Once we got dispose from server (or user initiated it himself), we'll ignore it if we we get it from server again - it's then up to the user to do some "disposing" action.
      • disposeInProgress

        private boolean disposeInProgress
      • syncRequestCounter

        private int syncRequestCounter
        Everytime we request server to sync data (typically after reconnect), we pass with a request counter, so that we can distinct the syncCompleted responses.
      • paused

        private boolean paused
      • currentLegionMarkerId

        private java.lang.String currentLegionMarkerId
      • lastMsgNr

        private int lastMsgNr
        is != -1 only from the point on when client abandons the connection, until sync is completed. When sync is completed, it's re-set back to -1.
      • oneConnectAttemptsRoundMutex

        private final java.lang.Object oneConnectAttemptsRoundMutex
      • oneConnectAttemptsRound

        private java.lang.Runnable oneConnectAttemptsRound
      • testCaseAutoDontFlee

        public boolean testCaseAutoDontFlee
      • testCaseAutoDenyNegotiate

        public boolean testCaseAutoDenyNegotiate
    • Constructor Detail

      • Client

        public Client​(java.lang.String playerName,
                      java.lang.String playerType,
                      WhatNextManager whatNextMgr,
                      Server theServer,
                      boolean byWebClient,
                      boolean noOptionsFile,
                      boolean createGUI,
                      ResourceLoader resLoader,
                      IServerConnection conn,
                      Variant variant,
                      boolean spectator)
        Client is the main hub for info exchange on client side.
        Parameters:
        playerName - Name of the player (might still be one of the templates
        playerType - Type of player, e.g. Human, Network, or some concrete AI type (but not "AnyAI"). Given type must include the package name.
        whatNextMgr - The main controller over which to handle what to do next when this game is over and exiting
        theServer - The Server object, if this is a local client
        byWebClient - If true, this was instantiated by a WebClient
        noOptionsFile - E.g. AIs should not read/save any options file
        createGUI - Whether to create a GUI (AI's usually not, but server might override that e.g. in stresstest)
        resLoader - The ResourceLoader object that gives us access to load images, files etc (from disk or from server)
        conn - The connection to server (so far, SocketClientThread)
        variant - The variant instance
        spectator - true to join as spectator, false as real player
    • Method Detail

      • createClient

        public static Client createClient​(java.lang.String host,
                                          int port,
                                          java.lang.String playerName,
                                          java.lang.String playerType,
                                          WhatNextManager whatNextMgr,
                                          Server theServer,
                                          boolean byWebClient,
                                          boolean noOptionsFile,
                                          boolean createGUI,
                                          boolean spectator)
                                   throws Client.ConnectionInitException
        Create a Client object and other related objects
        Parameters:
        host - The host to which SocketClientThread shall connect
        port - The port to which SocketClientThread shall connect
        playerName - Name of the player (might still be one of the templates
        playerType - Type of player, e.g. Human, Network, or some concrete AI type (but not "AnyAI"). Given type must include the package name.
        whatNextMgr - The main controller over which to handle what to do next when this game is over and exiting
        theServer - The Server object, if this is a local client
        byWebClient - If true, this was instantiated by a WebClient
        noOptionsFile - E.g. AIs should not read/save any options file
        createGUI - Whether to create a GUI (AI's usually not, but server might override that e.g. in stresstest)
        spectator - true to join as spectator, false as real player
        Throws:
        Client.ConnectionInitException
      • appendToConnectionLog

        public void appendToConnectionLog​(java.lang.String s)
        Specified by:
        appendToConnectionLog in interface IClient
      • isRemote

        public boolean isRemote()
      • isSpectator

        public boolean isSpectator()
      • isTheInternalSpectator

        public boolean isTheInternalSpectator()
      • isAlive

        public boolean isAlive()
      • isPaused

        public boolean isPaused()
      • setCurrentLegionMarkerId

        public void setCurrentLegionMarkerId​(java.lang.String MarkerId)
      • getCurrentLegionMarkerId

        public java.lang.String getCurrentLegionMarkerId()
      • setPauseState

        public void setPauseState​(boolean newState)
      • enforcedDisconnect

        public void enforcedDisconnect()
      • ensureThatConnected

        public boolean ensureThatConnected()
      • notifyThatNotConnected

        public void notifyThatNotConnected()
      • enforcedDisconnectByServer

        public void enforcedDisconnectByServer()
      • isConnected

        public boolean isConnected()
      • abandonCurrentConnection

        public void abandonCurrentConnection()
      • tryReconnect

        public void tryReconnect​(boolean automatic)
        Parameters:
        automatic - true if was triggered automatically e.g. by a Socket Exception, false if triggered manually (e.g. MasterBoard File menu).
      • guiTriggeredTryReconnect

        public void guiTriggeredTryReconnect()
      • setConnectAttemptsRoundCompleted

        private void setConnectAttemptsRoundCompleted()
      • isConnectRoundOngoing

        public boolean isConnectRoundOngoing()
      • fireOneReconnectRunnable

        private void fireOneReconnectRunnable​(boolean automatic)
        Creates a runnable that executes one reconnect round (several attempts)
      • tellSyncCompleted

        public void tellSyncCompleted​(int syncRequestNumber)
        Specified by:
        tellSyncCompleted in interface IClient
      • doCheckServerConnection

        public void doCheckServerConnection()
      • serverConfirmsConnection

        public void serverConfirmsConnection()
        Upon request with checkServerConnection, server sends a confirmation. This method here processes the confirmation.
        Specified by:
        serverConfirmsConnection in interface IClient
      • locallyInitiateSaveGame

        public void locallyInitiateSaveGame​(java.lang.String filename)
      • getFailed

        public boolean getFailed()
      • undoSplit

        public void undoSplit​(Legion splitoff)
      • mulligan

        public void mulligan()
        Take a mulligan.
      • tookMulligan

        public boolean tookMulligan()
      • engage

        public void engage​(MasterHex hex)
        Resolve engagement in land.
      • getMyEngagedLegion

        public Legion getMyEngagedLegion()
      • concede

        public void concede()
      • concede

        private void concede​(Legion legion)
      • doNotConcede

        private void doNotConcede​(Legion legion)
      • fight

        private void fight​(MasterHex hex)
        Cease negotiations and fight a battle in land.
      • tellEngagementResults

        public void tellEngagementResults​(Legion winner,
                                          java.lang.String method,
                                          int points,
                                          int turns)
        Specified by:
        tellEngagementResults in interface IClient
      • doSummon

        public void doSummon​(SummonInfo summonInfo)
        Legion target summons unit from Legion donor.
        Parameters:
        summonInfo - A SummonInfo object that contains the values for target, donor and unit.
      • withdrawFromGame

        public void withdrawFromGame()
        This player quits the whole game. The server needs to always honor this request, because if it doesn't players will just drop connections when they want to quit in a hurry.
      • tellMovementRoll

        public void tellMovementRoll​(int roll)
        Specified by:
        tellMovementRoll in interface IClient
      • tellWhatsHappening

        public void tellWhatsHappening​(java.lang.String message)
        Specified by:
        tellWhatsHappening in interface IClient
      • kickPhase

        public void kickPhase()
        Specified by:
        kickPhase in interface IClient
      • kickMoves

        private void kickMoves()
      • doAutoMoves

        private void doAutoMoves()
      • syncOption

        public void syncOption​(java.lang.String optname,
                               java.lang.String value)
        Server sends Client some option setting (e.g. AI type, autoPlay for stresstest (also AIs (????), ...)
        Specified by:
        syncOption in interface IClient
      • updatePlayerInfo

        public void updatePlayerInfo​(java.util.List<java.lang.String> infoStrings)
        Specified by:
        updatePlayerInfo in interface IClient
      • updateOnePlayersInfo

        public void updateOnePlayersInfo​(boolean redundant,
                                         java.lang.String reason,
                                         java.lang.String ShouldBeSeveralSeparateVariablesHerePerhaps)
        Specified by:
        updateOnePlayersInfo in interface IClient
      • setClosedByServer

        void setClosedByServer()
      • disposeClientOriginated

        public void disposeClientOriginated()
      • disposeWholeClient

        private void disposeWholeClient()
      • decideWhetherClose

        private boolean decideWhetherClose()
      • disposeAll

        private void disposeAll()
      • doAdditionalCleanup

        public void doAdditionalCleanup()
      • leaveCarryMode

        public void leaveCarryMode()
        Called from BattleBoard to leave carry mode.
      • doneWithBattleMoves

        public void doneWithBattleMoves()
      • getActiveBattleUnits

        public java.util.List<BattleUnit> getActiveBattleUnits()
      • sansLordAutoBattleApplies

        private boolean sansLordAutoBattleApplies()
      • getInactiveBattleUnits

        public java.util.List<BattleUnit> getInactiveBattleUnits()
      • aiDoneWithStrikes

        public void aiDoneWithStrikes()
      • doneWithStrikes

        public void doneWithStrikes()
      • makeForcedStrikes

        private boolean makeForcedStrikes()
        Return true if any strikes were taken.
      • strikeMakeForcedStrikes

        private boolean strikeMakeForcedStrikes​(boolean autoRangeSingle)
      • doAutoStrikes

        private void doAutoStrikes()
        Handle both forced strikes and AI strikes.
      • getLegion

        public LegionClientSide getLegion​(java.lang.String markerId)
        Get this legion's info or create if necessary. TODO move legion creation into a factory on Player
      • removeLegion

        public void removeLegion​(Legion legion)
        Remove this eliminated legion, and clean up related stuff.
        Specified by:
        removeLegion in interface IClient
      • getLegionHeight

        public int getLegionHeight​(java.lang.String markerId)
      • setLegionStatus

        public void setLegionStatus​(Legion legion,
                                    boolean moved,
                                    boolean teleported,
                                    EntrySide entrySide,
                                    CreatureType lastRecruit)
        Needed when loading a game outside split phase.
        Specified by:
        setLegionStatus in interface IClient
      • addCreature

        public void addCreature​(Legion legion,
                                CreatureType creature,
                                java.lang.String reason)
        Add a new creature to this legion.
        Specified by:
        addCreature in interface IClient
      • revealCreatures

        public void revealCreatures​(Legion legion,
                                    java.util.List<CreatureType> creatures,
                                    java.lang.String reason)
        Reveal creatures in this legion, some of which already may be known. - this "reveal" is related to data coming from server being revealed to the split prediction
        Specified by:
        revealCreatures in interface IClient
      • placeNewChit

        public void placeNewChit​(java.lang.String bareImageName,
                                 boolean inverted,
                                 int tag,
                                 BattleHex hex)
        Create a new BattleUnit and (if GUI) a new GUIBattleChit with the given parameters. Place them in given hex, and add them to the lists of BattleUnits (in Battle[ClientSide]) and GUIBattleChits (in GUI)
        Specified by:
        placeNewChit in interface IClient
      • tellReplay

        public void tellReplay​(boolean val,
                               int maxTurn)
        Specified by:
        tellReplay in interface IClient
      • isReplayOngoing

        public boolean isReplayOngoing()
      • tellRedo

        public void tellRedo​(boolean val)
        Specified by:
        tellRedo in interface IClient
      • isRedoOngoing

        public boolean isRedoOngoing()
      • initBoard

        public void initBoard()
        Specified by:
        initBoard in interface IClient
      • setPlayerName

        public void setPlayerName​(java.lang.String playerName)
        Specified by:
        setPlayerName in interface IClient
      • askAcquireAngel

        public void askAcquireAngel​(Legion legion,
                                    java.util.List<CreatureType> recruits)
        recruits is the list of acquirables that can be chosen from for a certain point value reached. E.g. for getting 180 points, going from 380 + 180 = 560, game would first call this for 400: recruits = [Angel] and then call it once more for 500: recruits = [Angel, Archangel]
        Specified by:
        askAcquireAngel in interface IClient
      • acquireAngelCallback

        public void acquireAngelCallback​(Legion legion,
                                         CreatureType angelType)
      • chooseWhetherToTeleport

        private boolean chooseWhetherToTeleport​(MasterHex hex)
        Present a dialog allowing the player to enter via land or teleport. Return true if the player chooses to teleport.
      • askChooseStrikePenalty

        public void askChooseStrikePenalty​(java.util.List<java.lang.String> choices)
        Allow the player to choose whether to take a penalty (fewer dice or higher strike number) in order to be allowed to carry.
        Specified by:
        askChooseStrikePenalty in interface IClient
      • assignStrikePenalty

        public void assignStrikePenalty​(java.lang.String prompt)
      • tellGameOver

        public void tellGameOver​(java.lang.String message,
                                 boolean disposeFollows)
        Specified by:
        tellGameOver in interface IClient
      • doFight

        public void doFight​(MasterHex hex)
      • answerFlee

        public void answerFlee​(Legion ally,
                               boolean answer)
      • answerConcede

        public void answerConcede​(Legion legion,
                                  boolean answer)
      • tellProposal

        public void tellProposal​(java.lang.String proposalString)
        Inform this player about the other player's proposal.
        Specified by:
        tellProposal in interface IClient
      • negotiateCallback

        public void negotiateCallback​(Proposal proposal,
                                      boolean respawn)
        Called from both Negotiate and ReplyToProposal.
      • makeProposal

        private void makeProposal​(Proposal proposal)
      • tellSlowResults

        public void tellSlowResults​(int targetTag,
                                    int slowValue)
        Specified by:
        tellSlowResults in interface IClient
      • tellStrikeResults

        public void tellStrikeResults​(int strikerTag,
                                      int targetTag,
                                      int strikeNumber,
                                      java.util.List<java.lang.String> rolls,
                                      int damage,
                                      boolean killed,
                                      boolean wasCarry,
                                      int carryDamageLeft,
                                      java.util.Set<java.lang.String> carryTargetDescriptions)
        Specified by:
        tellStrikeResults in interface IClient
      • nak

        public void nak​(java.lang.String reason,
                        java.lang.String errmsg)
        Specified by:
        nak in interface IClient
      • recoverFromNak

        private void recoverFromNak​(java.lang.String reason,
                                    java.lang.String errmsg)
      • pickCarries

        private void pickCarries​(int carryDamage,
                                 java.util.Set<java.lang.String> carryTargetDescriptions)
      • messageFromServer

        public void messageFromServer​(java.lang.String message)
        Specified by:
        messageFromServer in interface IClient
      • showMessageDialog

        public void showMessageDialog​(java.lang.String message)
      • canRecruit

        public boolean canRecruit​(Legion legion)
      • doRecruit

        public void doRecruit​(Legion legion)
        Used for human players only.
      • doRecruit

        public void doRecruit​(Legion legion,
                              java.lang.String recruitName,
                              java.lang.String recruiterName)
      • doReinforce

        public void doReinforce​(Legion legion)
        Always needs to call server.doRecruit(), even if no recruit is wanted, to get past the reinforcing phase.
        Specified by:
        doReinforce in interface IClient
      • undoRecruit

        public void undoRecruit​(Legion legion)
      • findRecruiterName

        private java.lang.String findRecruiterName​(Legion legion,
                                                   CreatureType recruit,
                                                   java.lang.String hexDescription)
        null means cancel. "none" means no recruiter (tower creature).
      • resetLegionMovesAndRecruitData

        private void resetLegionMovesAndRecruitData()
      • setBoardActive

        public void setBoardActive​(boolean val)
        Specified by:
        setBoardActive in interface IClient
      • setupTurnState

        public void setupTurnState​(Player activePlayer,
                                   int turnNumber)
        Called by server when activePlayer changes
        Specified by:
        setupTurnState in interface IClient
      • setupSplit

        public void setupSplit​(Player activePlayer,
                               int turnNumber)
        Specified by:
        setupSplit in interface IClient
      • kickSplit

        private void kickSplit()
      • setupMove

        public void setupMove()
        Specified by:
        setupMove in interface IClient
      • setupFight

        public void setupFight()
        Specified by:
        setupFight in interface IClient
      • kickFight

        private void kickFight()
      • setupMuster

        public void setupMuster()
        Specified by:
        setupMuster in interface IClient
      • kickMuster

        private void kickMuster()
      • setupBattleSummon

        public void setupBattleSummon​(Player battleActivePlayer,
                                      int battleTurnNumber)
        Specified by:
        setupBattleSummon in interface IClient
      • setupBattleRecruit

        public void setupBattleRecruit​(Player battleActivePlayer,
                                       int battleTurnNumber)
        Specified by:
        setupBattleRecruit in interface IClient
      • setupBattleMove

        public void setupBattleMove​(Player battleActivePlayer,
                                    int battleTurnNumber)
        Specified by:
        setupBattleMove in interface IClient
      • kickBattleMove

        private void kickBattleMove()
      • tryBattleMove

        public void tryBattleMove​(CritterMove cm)
      • retryFailedBattleMoves

        private void retryFailedBattleMoves()
      • getShortColor

        public java.lang.String getShortColor()
      • getDefender

        public Legion getDefender()
      • getAttacker

        public Legion getAttacker()
      • getBattleSite

        public MasterHex getBattleSite()
      • getBattleTurnNumber

        public int getBattleTurnNumber()
      • doBattleMove

        public void doBattleMove​(int tag,
                                 BattleHex hex)
      • undoBattleMove

        public void undoBattleMove​(BattleHex hex)
      • markBattleMoveSuccessful

        private void markBattleMoveSuccessful​(int tag,
                                              BattleHex endingHex)
      • handleFailedBattleMove

        private void handleFailedBattleMove​(java.lang.String errmsg)
      • strike

        public void strike​(int tag,
                           BattleHex hex)
        Attempt to have critter tag strike the critter in hex.
      • applyCarries

        public void applyCarries​(BattleHex hex)
        Attempt to apply carries to the critter in hex.
      • isInContact

        public boolean isInContact​(BattleCritter critter,
                                   boolean countDead)
      • findMobileCritterHexes

        public java.util.Set<BattleHex> findMobileCritterHexes()
        Return a set of hexLabels.
      • findMobileBattleUnits

        public java.util.Set<BattleUnit> findMobileBattleUnits()
        Return a set of BattleUnits.
      • findCrittersWithTargets

        public java.util.Set<BattleHex> findCrittersWithTargets()
      • findStrikes

        public java.util.Set<BattleHex> findStrikes​(int tag)
      • getPlayerByName

        public Player getPlayerByName​(java.lang.String name)
      • getPhase

        public Phase getPhase()
      • listTeleportingLords

        private java.util.List<CreatureType> listTeleportingLords​(Legion legion,
                                                                  MasterHex hex)
        List the lords eligible to teleport this legion to hexLabel.
      • doMove

        public boolean doMove​(Legion mover,
                              MasterHex hex)
        If the move looks legal, forward it to server and return true; otherwise returns false. Also let user or AI pick teleporting Lord and/or entry side, if relevant.
      • undoMove

        public void undoMove​(Legion legion)
      • relocateLegion

        public void relocateLegion​(Legion legion,
                                   MasterHex destination)
      • resetRecruitReservations

        public void resetRecruitReservations()
      • reserveRecruit

        public boolean reserveRecruit​(CreatureType recruitType)
      • getReservedRemain

        public int getReservedRemain​(CreatureType recruitType)
      • findEligibleRecruits

        public java.util.List<CreatureType> findEligibleRecruits​(Legion legion,
                                                                 MasterHex hex)
        Return a list of Creatures (ignore reservations).
      • findEligibleRecruits

        public java.util.List<CreatureType> findEligibleRecruits​(Legion legion,
                                                                 MasterHex hex,
                                                                 boolean considerReservations)
        Return a list of Creatures and consider reservations if wanted.
        Parameters:
        legion - The legion to recruit with.
        hex - The hex in which to recruit (not necessarily the same as the legion's position). Not null.
        considerReservations - Flag to determine if reservations should be considered.
        Returns:
        A list of possible recruits for the legion in the hex.
      • findEligibleRecruiters

        public java.util.List<java.lang.String> findEligibleRecruiters​(Legion legion,
                                                                       CreatureType recruit)
        Return a list of creature name strings. TODO return List
      • getPossibleRecruitHexes

        public java.util.Set<MasterHex> getPossibleRecruitHexes()
        Return a set of hexes with legions that can (still) muster anything and are not marked as skip.
      • getPossibleRecruitActionHexes

        private java.util.Set<MasterHex> getPossibleRecruitActionHexes()
        Return a set of hexLabels with legions that could do a recruit or undo recruit. Used for "if there is nothing to do in this recruit phase, muster phase can immediately be "doneWithRecruit".
      • noRecruitActionPossible

        public boolean noRecruitActionPossible()
        Check whether any legion has possibility to recruit at all, no matter whether it could or has already. If there is none, autoDone can automatically be done with recruit phase; but if there is something (e.g. autoRecruit has recruited something, allow human to override/force him to really confirm "Done".
        Returns:
        Whether there is any legion that could recruit or undoRecruit
      • listTeleportMoves

        public java.util.Set<MasterHex> listTeleportMoves​(Legion legion)
        Return a set of hexLabels.
      • listNormalMoves

        public java.util.Set<MasterHex> listNormalMoves​(Legion legion)
        Return a set of hexLabels.
      • legionsNotMoved

        public void legionsNotMoved​(int[] legionStatus,
                                    boolean have_roll)
        Returns status of client's legions
        Parameters:
        legionStatus - an array of integers with various status states to be set. Array should be initialized to all zeroes Current array contents: [Constants.legionStatusCount] == count of legions [Constants.legionStatusMoved] == legions that have moved [Constants.legionStatusBlocked] == unmoved legions with no legal move [Constants.legionStatusNotVisitedSkippedBlocked] == legions that have not been moved, are not blocked and have not been skipped
      • findUnmovedLegionHexes

        public java.util.Set<MasterHex> findUnmovedLegionHexes​(boolean considerSkippedAsMoved,
                                                               java.util.HashSet<Legion> pendingLegions)
      • findTallLegionHexes

        public java.util.Set<MasterHex> findTallLegionHexes()
        Return a set of hexLabels for the active player's legions with 7 or more creatures, and which are not marked as skip this turn.
      • findTallLegionHexes

        public java.util.Set<MasterHex> findTallLegionHexes​(int minHeight,
                                                            boolean ignoreSkipFlag)
        Return a set of hexLabels for the active player's legions with minHeight or more creatures.
        Parameters:
        ignoreSkipFlag - Set to true, legion will be considered even if it was marked as "skip this time".
      • notifyServer

        public void notifyServer()
      • isSctAlreadyDown

        public boolean isSctAlreadyDown()
      • doneWithSplits

        public void doneWithSplits()
      • doneWithMoves

        public void doneWithMoves()
      • doneWithEngagements

        public void doneWithEngagements()
      • doneWithRecruits

        public void doneWithRecruits()
      • isMyLegion

        public boolean isMyLegion​(Legion legion)
      • isMyTurn

        public boolean isMyTurn()
      • isMyBattlePhase

        public boolean isMyBattlePhase()
      • doSplit

        public void doSplit​(Legion parent)
        Called by MasterBoard.actOnLegion() when human user clicked on a legion to split it. This method here then: Verifies that splitting is legal and possible at all; Then get a child marker selected (either by dialog, or if autoPickMarker set, ask AI to pick one); If childMarkerId selection was not canceled (returned non-null), bring up the split dialog (which creatures go into which legion); and if that returns a list (not null) then call doSplit(...,...,...) which sends the request to server.
        Parameters:
        parent - The legion selected to split
      • doTheSplitting

        public void doTheSplitting​(Legion parent,
                                   java.lang.String childId)
      • doSplit

        public void doSplit​(Legion parent,
                            java.lang.String childMarkerId,
                            java.util.List<CreatureType> results)
        Called by AI and by doSplit()
      • didSplit

        public void didSplit​(MasterHex hex,
                             Legion parent,
                             Legion child,
                             int childHeight,
                             java.util.List<CreatureType> splitoffs,
                             int turn)
        Callback from server after any successful split. TODO childHeight is probably redundant now that we pass the legion object
        Specified by:
        didSplit in interface IClient
      • answerPickColor

        public void answerPickColor​(PlayerColor color)
      • assignFirstMarker

        public void assignFirstMarker​(java.lang.String markerId)
      • log

        public void log​(java.lang.String message)
        Specified by:
        log in interface IClient
      • pingRequest

        public void pingRequest()
        Specified by:
        pingRequest in interface IClient
      • createAI

        private AI createAI​(java.lang.String playerType)
        Create the AI for this Client. If type is some (concrete) AI type, create that type of AI (then this is an AI player). Otherwise, create a SimpleAI as default (used by Human or Remote clients for the autoplay functionality).
        Parameters:
        playerType - Type of player for which to create an AI
        Returns:
        Some AI object, according to the situation
      • aiPause

        private void aiPause()
        Wait for aiDelay.
      • setupDelay

        private void setupDelay()
      • getGame

        public Game getGame()
      • getTerrains

        public java.util.Collection<MasterBoardTerrain> getTerrains()
        Return a collection of all possible terrains.
        Returns:
        A collection containing all instances of MasterBoardTerrain.
      • setPreferencesCheckBoxValue

        public void setPreferencesCheckBoxValue​(java.lang.String name,
                                                boolean value)
      • setPreferencesRadioButtonValue

        public void setPreferencesRadioButtonValue​(java.lang.String name,
                                                   boolean value)
      • editAddCreature

        public void editAddCreature​(java.lang.String markerId,
                                    java.lang.String creatureType)
      • editRemoveCreature

        public void editRemoveCreature​(java.lang.String markerId,
                                       java.lang.String creatureType)
      • editRelocateLegion

        public void editRelocateLegion​(java.lang.String markerId,
                                       java.lang.String hexLabel)