Class Client

java.lang.Object
net.sf.colossus.client.Client
All Implemented Interfaces:
IClient, IOracle, OptionObjectProvider, IVariant
public final class Client extends 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 Details

    • LOGGER

      private static final 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:

    • 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

    • game

      private final GameClientSide game
      The game in progress.

    • 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

    • movement

      private MovementClientSide movement

    • battleMovement

      private BattleMovement battleMovement

    • 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.

    • closedBy

      private Client.ClosedByConstant closedBy

    • MAX_RECONNECT_ATTEMPTS

      private static final int MAX_RECONNECT_ATTEMPTS
      See Also:

    • RECONNECT_RETRY_INTERVAL

      private static final int RECONNECT_RETRY_INTERVAL
      See Also:

    • tookMulligan

      private boolean tookMulligan

    • numSplitsThisTurn

      private int numSplitsThisTurn

    • delay

      private int delay

    • bestMoveOrder

      private List<CritterMove> bestMoveOrder
      For battle AI.

    • failedBattleMoves

      private List<CritterMove> failedBattleMoves

    • recruitReservations

      private final Hashtable<CreatureType, 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 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.

    • previousConn

      private IServerConnection previousConn

    • oneConnectAttemptsRoundMutex

      private final Object oneConnectAttemptsRoundMutex

    • oneConnectAttemptsRound

      private Runnable oneConnectAttemptsRound

    • testCaseAutoDontFlee

      public boolean testCaseAutoDontFlee

    • testCaseAutoDenyNegotiate

      public boolean testCaseAutoDenyNegotiate

  • Constructor Details

    • Client

      public Client(String playerName, 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 Details

    • createClient

      public static Client createClient(String host, int port, String playerName, 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(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(String MarkerId)

    • getCurrentLegionMarkerId

      public 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(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.

    • tellEngagement

      public void tellEngagement(MasterHex hex, Legion attacker, Legion defender)
      Specified by:
      tellEngagement in interface IClient

    • tellEngagementResults

      public void tellEngagementResults(Legion winner, 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.

    • didSummon

      public void didSummon(Legion summoner, Legion donor, CreatureType summon)
      Specified by:
      didSummon in interface IClient

    • 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(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(String optname, String value)
      Server sends Client some option setting (e.g. AI type, autoPlay for stresstest (also AIs (????), ...)
      Specified by:
      syncOption in interface IClient

    • getNumPlayers

      public int getNumPlayers()
      Specified by:
      getNumPlayers in interface IOracle

    • updatePlayerInfo

      public void updatePlayerInfo(List<String> infoStrings)
      Specified by:
      updatePlayerInfo in interface IClient

    • updateOnePlayersInfo

      public void updateOnePlayersInfo(boolean redundant, String reason, String ShouldBeSeveralSeparateVariablesHerePerhaps)
      Specified by:
      updateOnePlayersInfo in interface IClient

    • getOwningPlayer

      public PlayerClientSide getOwningPlayer()

    • setColor

      public void setColor(PlayerColor color)
      Specified by:
      setColor in interface IClient

    • updateCreatureCount

      public void updateCreatureCount(CreatureType type, int count, int deadCount)
      Specified by:
      updateCreatureCount in interface IClient

    • setClosedByServer

      void setClosedByServer()

    • disposeClientOriginated

      public void disposeClientOriginated()

    • disposeClient

      public void disposeClient()
      Specified by:
      disposeClient in interface IClient

    • 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 List<BattleUnit> getActiveBattleUnits()

    • sansLordAutoBattleApplies

      private boolean sansLordAutoBattleApplies()

    • getInactiveBattleUnits

      public 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(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(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

    • getLegionImageNames

      public List<String> getLegionImageNames(Legion legion)
      Specified by:
      getLegionImageNames in interface IOracle

    • getLegionCreatureCertainties

      public List<Boolean> getLegionCreatureCertainties(Legion legion)
      Specified by:
      getLegionCreatureCertainties in interface IOracle

    • addCreature

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

    • removeCreature

      public void removeCreature(Legion legion, CreatureType creature, String reason)
      Specified by:
      removeCreature in interface IClient

    • revealCreatures

      public void revealCreatures(Legion legion, List<CreatureType> creatures, 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

    • revealEngagedCreatures

      public void revealEngagedCreatures(Legion legion, List<CreatureType> names, boolean isAttacker, String reason)
      Specified by:
      revealEngagedCreatures in interface IClient

    • removeDeadBattleChits

      public void removeDeadBattleChits()
      Specified by:
      removeDeadBattleChits in interface IClient

    • placeNewChit

      public void placeNewChit(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

    • chooseBestPotentialRecruit

      public CreatureType chooseBestPotentialRecruit(LegionClientSide legion, MasterHex hex, List<CreatureType> recruits)

    • getGUI

      public IClientGUI getGUI()

    • 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()

    • confirmWhenCaughtUp

      public void confirmWhenCaughtUp()
      Specified by:
      confirmWhenCaughtUp in interface IClient

    • initBoard

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

    • setPlayerName

      public void setPlayerName(String playerName)
      Specified by:
      setPlayerName in interface IClient

    • createSummonAngel

      public void createSummonAngel(Legion legion)
      Specified by:
      createSummonAngel in interface IClient

    • askAcquireAngel

      public void askAcquireAngel(Legion legion, 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(List<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(String prompt)

    • tellPlayerElim

      public void tellPlayerElim(Player deadPlayer, Player slayer)
      Specified by:
      tellPlayerElim in interface IClient

    • tellGameOver

      public void tellGameOver(String message, boolean disposeFollows)
      Specified by:
      tellGameOver in interface IClient

    • doFight

      public void doFight(MasterHex hex)

    • askConcede

      public void askConcede(Legion ally, Legion enemy)
      Specified by:
      askConcede in interface IClient

    • askFlee

      public void askFlee(Legion ally, Legion enemy)
      Specified by:
      askFlee in interface IClient

    • answerFlee

      public void answerFlee(Legion ally, boolean answer)

    • answerConcede

      public void answerConcede(Legion legion, boolean answer)

    • askNegotiate

      public void askNegotiate(Legion attacker, Legion defender)
      Specified by:
      askNegotiate in interface IClient

    • tellProposal

      public void tellProposal(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, List<String> rolls, int damage, boolean killed, boolean wasCarry, int carryDamageLeft, Set<String> carryTargetDescriptions)
      Specified by:
      tellStrikeResults in interface IClient

    • nak

      public void nak(String reason, String errmsg)
      Specified by:
      nak in interface IClient

    • recoverFromNak

      private void recoverFromNak(String reason, String errmsg)

    • pickCarries

      private void pickCarries(int carryDamage, Set<String> carryTargetDescriptions)

    • initBattle

      public void initBattle(MasterHex hex, int battleTurnNumber, Player battleActivePlayer, BattlePhase battlePhase, Legion attacker, Legion defender)
      Specified by:
      initBattle in interface IClient

    • messageFromServer

      public void messageFromServer(String message)
      Specified by:
      messageFromServer in interface IClient

    • showMessageDialog

      public void showMessageDialog(String message)

    • cleanupBattle

      public void cleanupBattle()
      Specified by:
      cleanupBattle in interface IClient

    • canRecruit

      public boolean canRecruit(Legion legion)

    • doRecruit

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

    • doRecruit

      public void doRecruit(Legion legion, String recruitName, 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

    • didRecruit

      public void didRecruit(Legion legion, CreatureType recruit, CreatureType recruiter, int numRecruiters)
      Specified by:
      didRecruit in interface IClient

    • undoRecruit

      public void undoRecruit(Legion legion)

    • undidRecruit

      public void undidRecruit(Legion legion, CreatureType recruit)
      Specified by:
      undidRecruit in interface IClient

    • findRecruiterName

      private String findRecruiterName(Legion legion, CreatureType recruit, 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()

    • nextEngagement

      public void nextEngagement()
      Specified by:
      nextEngagement in interface IClient

    • 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()

    • getBattleCS

      public BattleClientSide getBattleCS()
      Specified by:
      getBattleCS in interface IOracle

    • setupBattleFight

      public void setupBattleFight(BattlePhase battlePhase, Player battleActivePlayer)
      Used for both strike and strikeback.
      Specified by:
      setupBattleFight in interface IClient

    • tellLegionLocation

      public void tellLegionLocation(Legion legion, MasterHex hex)
      Create marker if necessary, and place it in hexLabel.
      Specified by:
      tellLegionLocation in interface IClient

    • getColor

      public PlayerColor getColor()

    • getShortColor

      public String getShortColor()

    • getBattleActivePlayer

      public Player getBattleActivePlayer()
      Specified by:
      getBattleActivePlayer in interface IOracle

    • getEngagement

      public Engagement getEngagement()
      Specified by:
      getEngagement in interface IOracle

    • getDefender

      public Legion getDefender()

    • getAttacker

      public Legion getAttacker()

    • getBattleSite

      public MasterHex getBattleSite()

    • getBattlePhase

      public BattlePhase getBattlePhase()
      Specified by:
      getBattlePhase in interface IOracle

    • 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(String errmsg)

    • tellBattleMove

      public void tellBattleMove(int tag, BattleHex startingHex, BattleHex endingHex, boolean undo)
      Specified by:
      tellBattleMove in interface IClient

    • 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 Set<BattleHex> findMobileCritterHexes()
      Return a set of hexLabels.

    • findMobileBattleUnits

      public Set<BattleUnit> findMobileBattleUnits()
      Return a set of BattleUnits.

    • showBattleMoves

      public Set<BattleHex> showBattleMoves(BattleCritter battleCritter)

    • findCrittersWithTargets

      public Set<BattleHex> findCrittersWithTargets()

    • findStrikes

      public Set<BattleHex> findStrikes(int tag)

    • getPlayerByName

      public Player getPlayerByName(String name)

    • getActivePlayer

      public Player getActivePlayer()
      Specified by:
      getActivePlayer in interface IOracle

    • getPhase

      public Phase getPhase()

    • getTurnNumber

      public int getTurnNumber()
      Specified by:
      getTurnNumber in interface IOracle

    • figureTeleportingLord

      private CreatureType figureTeleportingLord(Legion legion, MasterHex hex)

    • listTeleportingLords

      private 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.

    • didMove

      public void didMove(Legion legion, MasterHex startingHex, MasterHex currentHex, EntrySide entrySide, boolean teleport, CreatureType teleportingLord, boolean splitLegionHasForcedMove)
      Specified by:
      didMove in interface IClient

    • undoMove

      public void undoMove(Legion legion)

    • undidMove

      public void undidMove(Legion legion, MasterHex formerHex, MasterHex currentHex, boolean splitLegionHasForcedMove)
      Specified by:
      undidMove in interface IClient

    • 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 List<CreatureType> findEligibleRecruits(Legion legion, MasterHex hex)
      Return a list of Creatures (ignore reservations).

    • findEligibleRecruits

      public 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 List<String> findEligibleRecruiters(Legion legion, CreatureType recruit)
      Return a list of creature name strings. TODO return List

    • getPossibleRecruitHexes

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

    • getPossibleRecruitActionHexes

      private 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

    • getMovement

      public MovementClientSide getMovement()

    • listTeleportMoves

      public Set<MasterHex> listTeleportMoves(Legion legion)
      Return a set of hexLabels.

    • listNormalMoves

      public 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 Set<MasterHex> findUnmovedLegionHexes(boolean considerSkippedAsMoved, HashSet<Legion> pendingLegions)

    • findTallLegionHexes

      public 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 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()

    • undidSplit

      public void undidSplit(Legion splitoff, Legion survivor, int turn)
      Specified by:
      undidSplit in interface IClient

    • 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, String childId)

    • doSplit

      public void doSplit(Legion parent, String childMarkerId, List<CreatureType> results)
      Called by AI and by doSplit()

    • didSplit

      public void didSplit(MasterHex hex, Legion parent, Legion child, int childHeight, 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

    • askPickColor

      public void askPickColor(List<PlayerColor> colorsLeft)
      Specified by:
      askPickColor in interface IClient

    • answerPickColor

      public void answerPickColor(PlayerColor color)

    • askPickFirstMarker

      public void askPickFirstMarker()
      Specified by:
      askPickFirstMarker in interface IClient

    • assignFirstMarker

      public void assignFirstMarker(String markerId)

    • log

      public void log(String message)
      Specified by:
      log in interface IClient

    • pingRequest

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

    • testBattleMove

      public boolean testBattleMove(BattleCritter battleUnit, BattleHex hex)

    • createAI

      private AI createAI(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()

    • getGameClientSide

      public GameClientSide getGameClientSide()

    • getOptions

      public Options getOptions()
      Specified by:
      getOptions in interface OptionObjectProvider

    • getPossibleRecruits

      public List<CreatureType> getPossibleRecruits(MasterBoardTerrain terrain, MasterHex hex)
      TODO get from Variant instead of static TerrainRecruitLoader access Just forwarding the query, to get at least the GUI classes get rid of dependency to static TerrainRecruitLoader access. TerrainRecruitLoader.getPossibleRecruits(MasterBoardTerrain, MasterHex)
      Specified by:
      getPossibleRecruits in interface IVariant

    • numberOfRecruiterNeeded

      public int numberOfRecruiterNeeded(CreatureType recruiter, CreatureType recruit, MasterBoardTerrain terrain, MasterHex hex)
      TODO get from Variant instead of static TerrainRecruitLoader access Just forwarding the query, to get at least the GUI classes get rid of dependency to static TerrainRecruitLoader access. TerrainRecruitLoader.numberOfRecruiterNeeded(CreatureType, CreatureType, MasterBoardTerrain, MasterHex)
      Specified by:
      numberOfRecruiterNeeded in interface IVariant

    • getTerrains

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

    • setPreferencesCheckBoxValue

      public void setPreferencesCheckBoxValue(String name, boolean value)

    • setPreferencesRadioButtonValue

      public void setPreferencesRadioButtonValue(String name, boolean value)

    • editAddCreature

      public void editAddCreature(String markerId, String creatureType)

    • editRemoveCreature

      public void editRemoveCreature(String markerId, String creatureType)

    • editRelocateLegion

      public void editRelocateLegion(String markerId, String hexLabel)