Uses of Class
VASSAL.command.Command

Packages that use Command

Package	Description
VASSAL.build	Provides classes for building Java instances automatically from XML files.
VASSAL.build.module	Contains classes that may be added to a GameModule.
VASSAL.build.module.chessclockcontrol
VASSAL.build.module.documentation	Contains classes that may be added to a Documentation.
VASSAL.build.module.map	Contains classes that may be added to a Map.
VASSAL.build.module.map.boardPicker.board.mapgrid	Contains classes that may be added to a MapGrid.
VASSAL.build.module.noteswindow	Contains classes that may be added to a NotesWindow.
VASSAL.build.module.properties
VASSAL.build.module.turn
VASSAL.chat	Contains classes for specifying a VASSAL server implementation that follows a chat-room paradigm.
VASSAL.chat.node
VASSAL.chat.peer2peer
VASSAL.command	Provides classes that implement the "Command" design pattern.
VASSAL.counters	Provides classes that define game pieces.
VASSAL.property

Uses of Command in VASSAL.build

Methods in VASSAL.build that return Command

Modifier and Type	Method	Description
Command	GameModule.decode(String command)	Decodes our inbound Command traffic -- incoming player commands ready to be executed.
Command	AbstractToolbarItem.getRestoreCommand()
Command	GameModule.resumeLogging()	Restart logging and return any outstanding commands

Methods in VASSAL.build with parameters of type Command

Modifier and Type	Method	Description
String	GameModule.encode(Command c)	Encodes our outbound Command traffic -- outgoing player commands to be sent to other players' clients via either online (server) or logfile (PBEM).
void	GameModule.sendAndLog(Command c)	When the local player has taken any action that would change the game state (or otherwise needs to be sent to any other players' clients), the action should be encapsulated into a Command and sent here.

Uses of Command in VASSAL.build.module

Subclasses of Command in VASSAL.build.module

Modifier and Type	Class	Description
static class	BasicLogger.LogCommand
static class	BasicLogger.UndoCommand	A Command that records whether or not an Undo is in progress.
static class	Chatter.DisplayText	This is a Command object that, when executed, displays a text message in the Chatter's text area
static class	EventLog.StoreEvents
static class	GameState.SetupCommand
static class	ModuleExtension.RegCmd	A command that verifies that a certain extension has been loaded
static class	ModulePlugin.RegCmd
static class	NewGameIndicator.MarkGameNotNew
protected class	NotesWindow.SetPublicNote
protected class	NotesWindow.SetScenarioNote
static class	ObscurableOptions.SetAllowed
static class	PlayerRoster.Add
static class	PlayerRoster.Remove
static class	SpecialDiceButton.ShowResults	Command for displaying the results of a roll of the dice

Fields in VASSAL.build.module declared as Command

Modifier and Type	Field	Description
protected Command	BasicLogger.beginningState
protected Command	BasicLogger.LogCommand.logged

Fields in VASSAL.build.module with type parameters of type Command

Modifier and Type	Field	Description
protected List<Command>	BasicLogger.LogCommand.logInput
protected List<Command>	BasicLogger.logInput
protected List<Command>	BasicLogger.logOutput

Methods in VASSAL.build.module that return Command

Modifier and Type	Method	Description
Command	Map.apply(PieceVisitorDispatcher commandFactory)	Attempts to apply the provided PieceVisitorDispatcher to all pieces on this map, until it finds one that returns a non-null Command.
protected Command	BasicLogger.LogCommand.assembleCommand()
Command	BasicCommandEncoder.decode(String command)	Deserializes a string into a Basic Piece command (Add, Remove, Change, Move, and...
Command	BasicLogger.decode(String command)
Command	Chatter.decode(String s)
Command	ChessClockControl.decode(String command)	Deserializes our command from a string version, if the command belongs to us.
Command	EventLog.decode(String s)
Command	ExtensionsLoader.decode(String command)
Command	GameRefresher.decode(String s)
Command	GameState.decode(String theCommand)	A GameState recognizes instances of GameState.SetupCommand
Command	InternetDiceButton.decode(String command)
Command	NewGameIndicator.decode(String command)
Command	NotesWindow.decode(String command)
Command	ObscurableOptions.decode(String command)
Command	PlayerRoster.decode(String command)
Command	PluginsLoader.decode(String command)
Command	SpecialDiceButton.decode(String s)
Command	StartupGlobalKeyCommand.decode(String command)	Deserializes our command from a string version, if the command belongs to us.
Command	GameState.decodeSavedGame(File saveFile)	Read a saved game and translate it into a Command.
Command	GameState.decodeSavedGame(InputStream in)
protected Command	Inventory.HotKeySender.getCommand(Inventory.CounterNode node, KeyStroke stroke)
Command	BasicLogger.LogCommand.getLoggedCommand()
Command	BasicLogger.getRestoreCommand()
Command	ChessClockControl.getRestoreCommand()
Command	EventLog.getRestoreCommand()
Command	GameComponent.getRestoreCommand()	When saving a game, each GameComponent should return a Command that, when executed, restores the GameComponent to its state when the game was saved If this component has no persistent state, return null
Command	GameRefresher.getRestoreCommand()
Command	GameState.getRestoreCommand()
Command	InternetDiceButton.getRestoreCommand()
Command	Inventory.getRestoreCommand()
Command	Map.getRestoreCommand()	As a GameComponent, Map does not have any action inherently needing to be taken for "restoring" itself for load/save and network play purposes (the locations of pieces, etc, are stored in the pieces, and are restored from GameState in its GameState.getRestorePiecesCommand() method, which creates an AddPiece command for each piece).
Command	ModuleExtension.getRestoreCommand()
Command	ModulePlugin.getRestoreCommand()
Command	NewGameIndicator.getRestoreCommand()
Command	NotesWindow.getRestoreCommand()
Command	ObscurableOptions.getRestoreCommand()
Command	PlayerRoster.getRestoreCommand()
Command	PredefinedSetup.getRestoreCommand()
Command	StartupGlobalKeyCommand.getRestoreCommand()
Command	ToolbarMenu.getRestoreCommand()
Command	GameState.getRestorePiecesCommand()
protected Command	WizardSupport.SavedGameLoader.loadSavedGame()
protected Command	WizardSupport.TutorialLoader.loadSavedGame()
protected Command	BasicLogger.LogCommand.myUndoCommand()
protected Command	BasicLogger.UndoCommand.myUndoCommand()
Command	Chatter.DisplayText.myUndoCommand()
Command	EventLog.StoreEvents.myUndoCommand()
protected Command	GameState.SetupCommand.myUndoCommand()
protected Command	Inventory.myUndoCommand()
protected Command	ModuleExtension.RegCmd.myUndoCommand()
protected Command	NewGameIndicator.MarkGameNotNew.myUndoCommand()
protected Command	NotesWindow.SetPublicNote.myUndoCommand()
protected Command	NotesWindow.SetScenarioNote.myUndoCommand()
protected Command	ObscurableOptions.SetAllowed.myUndoCommand()
protected Command	PlayerRoster.Add.myUndoCommand()
protected Command	PlayerRoster.Remove.myUndoCommand()
protected Command	SpecialDiceButton.ShowResults.myUndoCommand()
Command	Map.placeAt(GamePiece piece, Point pt)	Place a piece at the destination point.
Command	Map.placeOrMerge(GamePiece p, Point pt)	Move a piece to the destination point.
Command	AttachmentManager.removeAttachments(GamePiece piece)	A piece is being removed by a Delete or Replace Command.
protected Command	Inventory.sendHotKeyToPieces(KeyStroke keyStroke)
Command	ChessClockControl.startClock(ChessClock targetClock)
Command	ChessClockControl.startNextClock()
Command	ChessClockControl.startOpponentClock()
Command	ChessClockControl.stopAllClocks()
Command	ChessClockControl.stopClock(ChessClock targetClock)

Methods in VASSAL.build.module with parameters of type Command

Modifier and Type	Method	Description
protected void	DoActionButton.doHotKey(Command c, NamedKeyStroke key)
String	BasicCommandEncoder.encode(Command c)	Serializes a Basic Piece command (Add, Remove, Change, Move, and ...
String	BasicLogger.encode(Command c)	Recognizes a logging command.
String	Chatter.encode(Command c)
String	ChessClockControl.encode(Command c)	Serializes our command into a string, if it belongs to us
String	EventLog.encode(Command c)
String	ExtensionsLoader.encode(Command c)
String	GameRefresher.encode(Command c)
String	GameState.encode(Command c)	A GameState recognizes instances of GameState.SetupCommand
String	InternetDiceButton.encode(Command c)
String	NewGameIndicator.encode(Command c)
String	NotesWindow.encode(Command c)
String	ObscurableOptions.encode(Command c)
String	PlayerRoster.encode(Command c)
String	PluginsLoader.encode(Command c)
String	SpecialDiceButton.encode(Command c)
String	StartupGlobalKeyCommand.encode(Command c)	Serializes our command into a string, if it belongs to us
void	GameRefresher.execute(Set<String> options, Command command)	This method is used by PredefinedSetup.refresh() to update a PredefinedSetup in a GameModule The default execute() method calls: GameModule.getGameModule().getGameState().getAllPieces() to set the pieces list, this method provides an alternative way to specify which pieces should be refreshed.
protected void	DoActionButton.executeActions(Command command)	Execute the set of actions that make up this button and return the set of Commands generated.
void	BasicLogger.log(Command c)	Logs a Command to output
void	GameRefresher.refreshAllAttachments(Command command)	AFTER the piece refresh, we now need to go through and restore all the broken Attachment mappings using the indices we created.
void	GameRefresher.refreshAttachment(GamePiece piece, Command command)	For each *new* outermost piece that has Attachments, we look up the *old* outermost piece, and use its Unique ID plus each Attachment trait's name as a lookup hash to find the old list of contents.
void	ServerConnection.sendToOthers(Command c)	Send a command to other players on the server

Constructors in VASSAL.build.module with parameters of type Command

Modifier	Constructor	Description
	LogCommand(Command c, List<Command> logInput, Action stepAction)

Constructor parameters in VASSAL.build.module with type arguments of type Command

Modifier	Constructor	Description
	LogCommand(Command c, List<Command> logInput, Action stepAction)

Uses of Command in VASSAL.build.module.chessclockcontrol

Methods in VASSAL.build.module.chessclockcontrol that return Command

Modifier and Type	Method	Description
Command	ChessClock.decode(String command)	Deserializes our command from a string version, if the command belongs to us.
Command	ChessClock.getRestoreCommand()
Command	ChessClock.resetState()	Creates a command to reset the clock and turn it off
Command	ChessClock.startClock()	Creates a command to make this clock the currently ticking clock
Command	ChessClock.stopClock()	Creates a command to make this clock the currently ticking clock
Command	ChessClock.updateState(boolean ticking)	Creates a command to update the clock and/or turn it on/off.

Methods in VASSAL.build.module.chessclockcontrol with parameters of type Command

Modifier and Type	Method	Description
String	ChessClock.encode(Command c)	Serializes our command into a string, if it belongs to us

Uses of Command in VASSAL.build.module.documentation

Methods in VASSAL.build.module.documentation that return Command

Modifier and Type	Method	Description
Command	Tutorial.getTutorialCommand()

Uses of Command in VASSAL.build.module.map

Subclasses of Command in VASSAL.build.module.map

Modifier and Type	Class	Description
static class	BoardPicker.SetBoards
static class	LOS_Thread.LOSCommand

Methods in VASSAL.build.module.map that return Command

Modifier and Type	Method	Description
Command	DrawPile.addToContents(GamePiece p)
Command	DrawPile.addToContents(GamePiece p, boolean checkAccessibility)
Command	DeckGlobalKeyCommand.DeckGlobalCommand.apply(Deck d, PieceFilter filter)
protected Command	PieceMover.applyKeyAfterMove(List<GamePiece> pieces, KeyStroke key)	Applies a key command to each of a list of pieces.
Command	PieceMover.checkTrueMoved(GamePiece p)	For a piece, mark it moved IF it changed locations or mats
Command	BoardPicker.decode(String command)
Command	Flare.decode(String s)	Deserializes string command info into a Flare Command.
Command	LOS_Thread.decode(String command)
protected Command	PieceMover.doTrueMovedSupport(List<GamePiece> pieces)	For a list of pieces, mark them moved IF they changed locations or mats
Command	MovementReporter.getReportCommand()
Command	BoardPicker.getRestoreCommand()	The restore command of a BoardPicker, when executed, sets the boards of its Map to BoardPicker.getSelectedBoards()
Command	Flare.getRestoreCommand()
Command	GlobalMap.getRestoreCommand()
Command	HidePiecesButton.getRestoreCommand()
Command	HighlightLastMoved.getRestoreCommand()
Command	MapShader.getRestoreCommand()
Command	PieceMover.getRestoreCommand()	PieceMover has nothing to save/restore in a save file.
Command	SetupStack.getRestoreCommand()
Command	Zoomer.getRestoreCommand()
Command	MovementReporter.markMoved(GamePiece p)
Command	PieceMover.markMoved(GamePiece p, boolean hasMoved)
Command	PieceMover.markMoved(GamePiece p, boolean hasMoved, boolean locDefinitelyChanged)	Handles marking pieces as "moved" or "not moved", based on Global Options settings.
Command	MovementReporter.markMovedPieces()	Mark all pieces with the MovementMarkable trait
Command	HandMetrics.merge(GamePiece fixed, GamePiece moving)
Command	StackMetrics.merge(GamePiece fixed, GamePiece moving)	Place a GamePiece on top of another GamePiece Create/remove stacks as necessary, even if stacking is disabled for this instance
protected Command	PieceMover.movedPiece(GamePiece p, Point loc)	Invoked just BEFORE a piece is moved.
Command	PieceMover.movePieces(Map map, Point p)	This is the key method for handling the "Drop" part of Drag and Drop.
protected Command	BoardPicker.SetBoards.myUndoCommand()
protected Command	LOS_Thread.LOSCommand.myUndoCommand()
Command	StackMetrics.placeOrMerge(GamePiece fixed, GamePiece moving)	Merge the two pieces if stacking is enabled.
Command	PieceRecenterer.recenter(Map map)	Returns a Command that moves all pieces so that their centroid is centered on the map.
protected Command	PieceMover.setOldLocations(GamePiece p)	Populates the "OldLocations" properties (e.g.

Methods in VASSAL.build.module.map with parameters of type Command

Modifier and Type	Method	Description
protected MovementReporter	PieceMover.createMovementReporter(Command c)	Creates a MovementReporter for a collection of commands containing AddPiece and MovePiece commands, which will supply auto-report messages corresponding to those commands
String	BoardPicker.encode(Command c)
String	Flare.encode(Command c)	Serializes Flare commands into string form.
String	LOS_Thread.encode(Command c)
protected void	MovementReporter.extractMoveCommands(Command c)

Constructors in VASSAL.build.module.map with parameters of type Command

Modifier	Constructor	Description
	HiddenMovementReporter(Command moveCommand)
	MovementReporter(Command moveCommand)

Uses of Command in VASSAL.build.module.map.boardPicker.board.mapgrid

Methods in VASSAL.build.module.map.boardPicker.board.mapgrid that return Command

Modifier and Type	Method	Description
Command	Zone.getRestoreCommand()

Uses of Command in VASSAL.build.module.noteswindow

Subclasses of Command in VASSAL.build.module.noteswindow

Modifier and Type	Class	Description
class	AddSecretNoteCommand	When executed, adds a SecretNote to a specified List.
class	SetPrivateTextCommand	When executed, adds a PrivateText to a specified set.

Methods in VASSAL.build.module.noteswindow that return Command

Modifier and Type	Method	Description
Command	PrivateNotesController.decode(String command)
Command	SecretNotesController.decode(String command)
Command	PrivateNotesController.getRestoreCommand()
Command	SecretNotesController.getRestoreCommand()
protected Command	AddSecretNoteCommand.myUndoCommand()
protected Command	SetPrivateTextCommand.myUndoCommand()
Command	PrivateNotesController.save()
Command	SecretNotesController.save()

Methods in VASSAL.build.module.noteswindow with parameters of type Command

Modifier and Type	Method	Description
String	PrivateNotesController.encode(Command c)
String	SecretNotesController.encode(Command c)

Uses of Command in VASSAL.build.module.properties

Subclasses of Command in VASSAL.build.module.properties

Modifier and Type	Class	Description
class	ChangePropertyCommand	Command to change the value of a MutableProperty
static class	GlobalProperty.SetGlobalProperty	Command to pass a new Global property value to other players or into the logfile.
static class	ScenarioPropertiesOptionTab.LockScenarioOptionsTab	A Command to record the lock status of an individual Scenario Options tab

Methods in VASSAL.build.module.properties that return Command

Modifier and Type	Method	Description
Command	ChangePropertyCommandEncoder.decode(String command)
Command	GlobalProperty.decode(String command)
Command	ScenarioPropertiesOptionTab.decode(String command)
protected Command	MutableProperty.Impl.getChangeCommand(String oldValue, String newValue)
Command	GlobalProperty.getRestoreCommand()
Command	GlobalTranslatableMessage.getRestoreCommand()
Command	ScenarioOptions.getRestoreCommand()
Command	ScenarioPropertiesOptionTab.getRestoreCommand()
protected Command	ChangePropertyCommand.myUndoCommand()
protected Command	GlobalProperty.SetGlobalProperty.myUndoCommand()
protected Command	ScenarioPropertiesOptionTab.LockScenarioOptionsTab.myUndoCommand()
Command	GlobalProperty.setPropertyValue(String newValue)
Command	MutableProperty.Impl.setPropertyValue(String newValue)
Command	MutableProperty.setPropertyValue(String newValue)

Methods in VASSAL.build.module.properties with parameters of type Command

Modifier and Type	Method	Description
String	ChangePropertyCommandEncoder.encode(Command c)
String	GlobalProperty.encode(Command c)
String	ScenarioPropertiesOptionTab.encode(Command c)

Uses of Command in VASSAL.build.module.turn

Subclasses of Command in VASSAL.build.module.turn

Modifier and Type	Class	Description
static class	TurnTracker.SetTurn

Methods in VASSAL.build.module.turn that return Command

Modifier and Type	Method	Description
Command	TurnTracker.decode(String command)
Command	TurnTracker.getRestoreCommand()
protected Command	TurnTracker.SetTurn.myUndoCommand()

Methods in VASSAL.build.module.turn with parameters of type Command

Modifier and Type	Method	Description
String	TurnTracker.encode(Command c)

Uses of Command in VASSAL.chat

Subclasses of Command in VASSAL.chat

Modifier and Type	Class	Description
class	InviteCommand	A Command that, when executed, sends game synchronization information to a given SimplePlayer
class	PrivMsgCommand	A Command that encapsulates a private chat message from another SimplePlayer
static class	SoundEncoder.Cmd
class	SynchCommand	A Command that, when executed, sends game synchronization information to a given SimplePlayer

Methods in VASSAL.chat that return Command

Modifier and Type	Method	Description
Command	InviteEncoder.decode(String s)
Command	PrivateChatEncoder.decode(String s)
Command	SoundEncoder.decode(String command)
Command	SynchEncoder.decode(String s)
Command	DummyMessageServer.getWelcomeMessage()
Command	HttpMessageServer.getWelcomeMessage()
Command	WelcomeMessageServer.getWelcomeMessage()
protected Command	InviteCommand.myUndoCommand()
Command	PrivMsgCommand.myUndoCommand()
protected Command	SoundEncoder.Cmd.myUndoCommand()
protected Command	SynchCommand.myUndoCommand()

Methods in VASSAL.chat with parameters of type Command

Modifier and Type	Method	Description
protected boolean	MainRoomFilter.accept(Command c)
String	InviteEncoder.encode(Command c)
String	PrivateChatEncoder.encode(Command c)
String	SoundEncoder.encode(Command c)
String	SynchEncoder.encode(Command c)
void	ChatServerConnection.sendTo(Player recipient, Command c)	Send a Command to a particular player
void	DummyClient.sendTo(Player recipient, Command c)
void	HybridClient.sendTo(Player recipient, Command c)
void	DummyClient.sendToOthers(Command c)
void	HybridClient.sendToOthers(Command c)

Uses of Command in VASSAL.chat.node

Methods in VASSAL.chat.node with parameters of type Command

Modifier and Type	Method	Description
void	NodeClient.sendTo(Player recipient, Command c)
void	NodeClient.sendToOthers(Command c)

Uses of Command in VASSAL.chat.peer2peer

Subclasses of Command in VASSAL.chat.peer2peer

Modifier and Type	Class	Description
static class	TextClient.ShowText

Methods in VASSAL.chat.peer2peer that return Command

Modifier and Type	Method	Description
Command	TextClient.Encoder.decode(String command)
protected Command	TextClient.ShowText.myUndoCommand()

Methods in VASSAL.chat.peer2peer with parameters of type Command

Modifier and Type	Method	Description
String	TextClient.Encoder.encode(Command c)
void	P2PClient.sendTo(Player recipient, Command c)
void	P2PClient.sendToOthers(Command c)

Uses of Command in VASSAL.command

Subclasses of Command in VASSAL.command

Modifier and Type	Class	Description
class	AddPiece	This Command adds a GamePiece to a game.
class	AlertCommand	This command, when executed, displays a Dialog box with a message
class	ChangePiece	This Command changes the state of a GamePiece.
class	ConditionalCommand	Evaluates properties of the GameModule and conditionally executes another Command if all values are satisfied.
class	FlareCommand	A Command for sending Flare actions to other clients
class	MovePiece	Command that moves a piece to a new location and position within a stack.
class	NullCommand
class	PlayAudioClipCommand
class	RemovePiece	This Command removed a GamePiece from a game.
class	SetPersistentPropertyCommand	This Command sets a Persistent Property in a PersistentPropertyContainer.

Methods in VASSAL.command that return Command

Modifier and Type	Method	Description
Command	ChangePiece.append(Command c)
Command	Command.append(Command c)	Append a subcommand to this Command.
Command	CommandFilter.apply(Command c)	Apply the filter
Command	CommandEncoder.decode(String command)	Translate a String into a Command
Command	ChangeTracker.getChangeCommand()
Command	ConditionalCommand.getDelegate()
Command	MoveTracker.getMoveCommand()
Command[]	Command.getSubCommands()
Command	Command.getUndoCommand()
protected Command	AddPiece.myUndoCommand()
protected Command	AlertCommand.myUndoCommand()
protected Command	ChangePiece.myUndoCommand()
protected abstract Command	Command.myUndoCommand()	If the action can be undone, return a Command that performs the inverse action.
protected Command	ConditionalCommand.myUndoCommand()
protected Command	FlareCommand.myUndoCommand()
protected Command	MovePiece.myUndoCommand()
protected Command	NullCommand.myUndoCommand()
protected Command	PlayAudioClipCommand.myUndoCommand()
protected Command	RemovePiece.myUndoCommand()
protected Command	SetPersistentPropertyCommand.myUndoCommand()

Methods in VASSAL.command with parameters of type Command

Modifier and Type	Method	Description
protected abstract boolean	CommandFilter.accept(Command c)
Command	ChangePiece.append(Command c)
Command	Command.append(Command c)	Append a subcommand to this Command.
Command	CommandFilter.apply(Command c)	Apply the filter
String	CommandEncoder.encode(Command c)	Translate a Command into a String
void	Logger.log(Command c)

Constructors in VASSAL.command with parameters of type Command

Modifier	Constructor	Description
	ConditionalCommand(ConditionalCommand.Condition[] conditions, Command delegate)

Uses of Command in VASSAL.counters

Subclasses of Command in VASSAL.counters

Modifier and Type	Class	Description
protected static class	Deck.LoadDeckCommand	Command to set the contents of this deck from a saved file.

Fields in VASSAL.counters declared as Command

Modifier and Type	Field	Description
protected Command	GlobalCommandVisitor.command

Methods in VASSAL.counters that return Command

Modifier and Type	Method	Description
Command	CounterGlobalKeyCommand.apply()
Command	GlobalCommand.apply(Map[] maps, PieceFilter filter)	(Legacy - applies GKC without Fast Match)
Command	GlobalCommand.apply(Map[] maps, PieceFilter filter, GlobalCommandTarget fastMatch)	Apply the key command to all pieces that pass the given filter and our Fast Match GlobalCommandTarget parameters on all the given maps
Command	GlobalCommand.apply(Map[] maps, PieceFilter filter, GlobalCommandTarget fastMatch, AuditTrail audit)	Apply the key command to all pieces that pass the given filter and our Fast Match GlobalCommandTarget parameters on all the given maps
Command	GlobalCommand.apply(Map map, PieceFilter filter)	(Legacy - applies GKC without Fast Match)
Command	GlobalCommand.apply(Map map, PieceFilter filter, GlobalCommandTarget fastMatch)	Apply the key command on ONE SPECIFIC MAP to all pieces that pass the given filter and our Fast Match parameters.
Command	GlobalCommand.apply(Map map, PieceFilter filter, GlobalCommandTarget fastMatch, AuditTrail audit)
Command	Attachment.attach()	Runs a search using the provided filter (same as a Global Key Command), and any matching pieces become our attachments (stored in our "contents" list)
Command	DeckManager.checkEmptyDecks(Command c)	If any decks want to send their I-am-empty key, send it now.
default Command	EditablePiece.checkTrueMoved()	Centralized method used when finishing up after a piece moves.
default Command	GamePiece.checkTrueMoved()
protected Command	Translate.classicTranslate(KeyStroke stroke)	Classic Translate code.
Command	Attachment.clearAll()	Clears all existing attachment(s)
Command	Attachment.clearMatching()
protected Command	TriggerAction.doLoopOnce()
protected Command	TriggerAction.executeKey(NamedKeyStroke key)
Command	Deck.extendedSend(DeckSendKeyCommand dkc)	Extended Send to Deck Command, based on the configuration of the supplied DeckSendKeyCommand - Deck target can be variable - Optional limit on number of cards to send - Optionally limit selection of cards to those that match an expression - Optionally stop sending cards when a specific card seen (match expression).
Command	MatCargo.findNewMat()	Finds us a Mat to join at our current location.
Command	MatCargo.findNewMat(Map map, Point pt)	Finds us a Mat to join at the specified point on a specified map.
static Command	MatCargo.findNewMat(Command c, GamePiece gp)	Checks if GamePiece gp is a MatCargo, and if so finds it a new mat if needed (or clears it if it has moved off its former mat)
default Command	EditablePiece.finishMove(Command c, boolean afterburner, boolean findmat)
default Command	EditablePiece.finishMove(Command c, boolean afterburner, boolean findmat, boolean mark_moved)	Centralized method for finishing up after a piece moves.
default Command	GamePiece.finishMove(Command c, boolean afterburner, boolean findmat)
default Command	GamePiece.finishMove(Command c, boolean afterburner, boolean findmat, boolean markMoved)
Command	Translate.MoveExecuter.getAdditionalCommand()
Command	GlobalCommand.Visitor.getCommand()
Command	GlobalCommandVisitor.getCommand()
Command	Deck.importDeck()
Command	Deck.importDeck(File f)
Command	KeyBuffer.keyCommand(KeyStroke stroke)	Applies a key command to every selected piece (i.e.
Command	BasicPiece.keyEvent(KeyStroke stroke)	The primary way for the piece or trait to receive events.
Command	Decorator.keyEvent(KeyStroke stroke)	The primary way for the piece or trait to receive events.
Command	GamePiece.keyEvent(KeyStroke stroke)	The primary way for the piece or trait to receive events.
Command	Obscurable.keyEvent(KeyStroke stroke)
Command	ReportState.keyEvent(KeyStroke stroke)
Command	RestrictCommands.keyEvent(KeyStroke stroke)
Command	Restricted.keyEvent(KeyStroke stroke)
Command	Stack.keyEvent(KeyStroke stroke)	Processes a key command for this stack, by sending it to the top visible piece in the stack.
Command	Translate.keyEvent(KeyStroke stroke)
Command	TriggerAction.keyEvent(KeyStroke stroke)	Apply key commands to inner pieces first
Command	UsePrototype.keyEvent(KeyStroke stroke)
Command	Deck.loadDeck(File f)
Command	Mat.makeAddCargoCommand(GamePiece p)	Adds a piece of cargo and returns a command to duplicate the operation on another client
Command	Attachment.makeAddTargetCommand(GamePiece p)	Adds a target and returns a command to duplicate the operation on another client
Command	MatCargo.makeClearMatCommand()	Clear our relationship with any Mat we're assigned to, and return a command to do that.
Command	Mat.makeRemoveAllCargoCommand()	Remove all cargo from this Mat, and returns a Command to duplicate the changes on another client
Command	Mat.makeRemoveCargoCommand(GamePiece p)	Removes a MatCargo piece from our list of cargo, and returns a Command to duplicate the changes on another client
Command	Attachment.makeRemoveTargetCommand(GamePiece p)	Removes a piece from our list of targets, and returns a Command to duplicate the changes on another client
Command	MatCargo.makeSetMatCommand(GamePiece newMat)	Places us "on" the designated Mat and returns a Command to duplicate the changes on other clients
Command	SetPieceProperty.makeSetTargetCommand(GamePiece p)	Our filter has found a matching piece.
protected Command	FreeRotator.movePiece(GamePiece gp, Point dest)
protected Command	FreeRotator.movePiece(GamePiece gp, Point dest, boolean cargoFollowup)
protected Command	Translate.movePiece(GamePiece gp, Point dest)
protected Command	Translate.moveTarget(GamePiece target)
Command	ActionButton.myKeyEvent(KeyStroke stroke)
Command	AreaOfEffect.myKeyEvent(KeyStroke stroke)
Command	Attachment.myKeyEvent(KeyStroke stroke)
Command	BasicName.myKeyEvent(KeyStroke stroke)
Command	BorderOutline.myKeyEvent(KeyStroke stroke)
Command	CalculatedProperty.myKeyEvent(KeyStroke stroke)
Command	Clone.myKeyEvent(KeyStroke stroke)
Command	Comment.myKeyEvent(KeyStroke stroke)
Command	CounterGlobalKeyCommand.myKeyEvent(KeyStroke stroke)
abstract Command	Decorator.myKeyEvent(KeyStroke stroke)	The response of this trait alone to the given KeyStroke or the virtual keystroke of a NamedKeyStroke.
Command	Delete.myKeyEvent(KeyStroke stroke)
Command	Deselect.myKeyEvent(KeyStroke stroke)
Command	DynamicProperty.myKeyEvent(KeyStroke stroke)
Command	Embellishment.myKeyEvent(KeyStroke stroke)
Command	Embellishment0.myKeyEvent(KeyStroke stroke)
Command	Footprint.myKeyEvent(KeyStroke stroke)
Command	FreeRotator.myKeyEvent(KeyStroke stroke)
Command	GlobalHotKey.myKeyEvent(KeyStroke stroke)
Command	Hideable.myKeyEvent(KeyStroke stroke)
Command	Immobilized.myKeyEvent(KeyStroke e)
Command	Labeler.myKeyEvent(KeyStroke stroke)
Command	Marker.myKeyEvent(KeyStroke stroke)
Command	Mat.myKeyEvent(KeyStroke stroke)
Command	MatCargo.myKeyEvent(KeyStroke stroke)
Command	MenuSeparator.myKeyEvent(KeyStroke stroke)
Command	MovementMarkable.myKeyEvent(KeyStroke stroke)
Command	MultiLocationCommand.myKeyEvent(KeyStroke stroke)	If the stroke matches our key command, then call the funky "like a static but not actually static" GameModule thing to retrieve the specific menu command being processed -- that is then used to set values for our special trait properties (e.g.
Command	NonRectangular.myKeyEvent(KeyStroke stroke)
Command	Obscurable.myKeyEvent(KeyStroke stroke)
Command	Pivot.myKeyEvent(KeyStroke stroke)
Command	PlaceMarker.myKeyEvent(KeyStroke stroke)
Command	PlaySound.myKeyEvent(KeyStroke stroke)
Command	PropertySheet.myKeyEvent(KeyStroke stroke)
Command	Replace.myKeyEvent(KeyStroke stroke)
Command	ReportState.myKeyEvent(KeyStroke stroke)
Command	RestrictCommands.myKeyEvent(KeyStroke stroke)
Command	Restricted.myKeyEvent(KeyStroke stroke)
Command	ReturnToDeck.myKeyEvent(KeyStroke stroke)
Command	SendToLocation.myKeyEvent(KeyStroke stroke)
Command	SetGlobalProperty.myKeyEvent(KeyStroke stroke)
Command	SetPieceProperty.myKeyEvent(KeyStroke stroke)
Command	SubMenu.myKeyEvent(KeyStroke stroke)
Command	TableInfo.myKeyEvent(KeyStroke stroke)
Command	TranslatableMessage.myKeyEvent(KeyStroke stroke)
Command	Translate.myKeyEvent(KeyStroke stroke)
Command	TriggerAction.myKeyEvent(KeyStroke stroke)
Command	UsePrototype.myKeyEvent(KeyStroke stroke)
protected Command	Deck.LoadDeckCommand.myUndoCommand()
protected Command	Translate.newTranslate(KeyStroke stroke)
Command	Deck.pieceAdded(GamePiece p)
Command	Stack.pieceAdded(GamePiece p)	Perform some action on a GamePiece that has just been added to this Stack
Command	Deck.pieceRemoved(GamePiece p)
Command	Stack.pieceRemoved(GamePiece p)	Perform some action on a GamePiece that has just been removed this Stack
protected Command	PlaceMarker.placeMarker()
protected Command	PlaceMarker.placeMarker(boolean clearParentId)
default Command	EditablePiece.prepareMove(Command c, boolean mark_moved)	Centralized method for preparing a piece to move.
default Command	GamePiece.prepareMove(Command c, boolean mark_moved)
static Command	Decorator.putOldProperties(GamePiece p)	* Set the Oldxxxx properties related to movement (e.g.
protected Command	Replace.replacePiece()
protected Command	Deck.reportCommand(String format, String commandName)	Format command report as per module designers setup.
protected Command	Deck.reportCommand(FormattedString reportFormat, String commandName)	Format command report as per module designers setup.
Command	Deck.reverse()	Reverse the order of the contents of the Deck
Command	FreeRotator.rotateCargo(Command command, Point center, double dtheta)
Command	Deck.sendToDeck()	Combine the contents of this Deck with the contents of the deck specified by Deck.reshuffleTarget
Command	Deck.setContents(Collection<GamePiece> c)	Set the contents of this Deck to a Collection of GamePieces
Command	Deck.setContentsFaceDown(boolean value)
static Command	Decorator.setDynamicProperties(List<Parameter> parameters, GamePiece piece, PropertySource source, Auditable owner)	Find and set a series of Dynamic Properties in the supplied GamePiece named propertyName and generate a Command to set it to the specified values in other clients
static Command	Decorator.setDynamicProperties(List<Parameter> parameters, GamePiece piece, PropertySource source, Auditable owner, AuditTrail auditSoFar)
static Command	Decorator.setDynamicProperty(String propertyName, String value, GamePiece piece, PropertySource source, Auditable owner, AuditTrail audit)	Find a Dynamic Property in the supplied GamePiece named propertyName and generate a Command to set it to the specified value
Command	BasicPiece.setPersistentProperty(Object key, Object newValue)	Setting a persistent property writes a property value into the piece (creating a new entry in the piece's persistent property table if the specified key does not yet exist in it).
Command	Decorator.setPersistentProperty(Object key, Object val)	Default behavior for a Trait/Decorator is to pass requests to set persistent properties inward to the next member of the piece.
Command	Deck.shuffle()	Shuffle the contents of the Deck
Command	Deck.sort(List<SortParameter> sortParameters, FormattedString reportFormat, String menuCommand)	Sort the Deck.

Methods in VASSAL.counters with parameters of type Command

Modifier and Type	Method	Description
Command	DeckManager.checkEmptyDecks(Command c)	If any decks want to send their I-am-empty key, send it now.
static Command	MatCargo.findNewMat(Command c, GamePiece gp)	Checks if GamePiece gp is a MatCargo, and if so finds it a new mat if needed (or clears it if it has moved off its former mat)
default Command	EditablePiece.finishMove(Command c, boolean afterburner, boolean findmat)
default Command	EditablePiece.finishMove(Command c, boolean afterburner, boolean findmat, boolean mark_moved)	Centralized method for finishing up after a piece moves.
default Command	GamePiece.finishMove(Command c, boolean afterburner, boolean findmat)
default Command	GamePiece.finishMove(Command c, boolean afterburner, boolean findmat, boolean markMoved)
GlobalCommandVisitor	GlobalAttach.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
protected GlobalCommandVisitor	GlobalCommand.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
GlobalCommandVisitor	GlobalDetach.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
GlobalCommandVisitor	GlobalSetter.getVisitor(Command command, PieceFilter filter, KeyStroke keyStroke, AuditTrail audit, Auditable owner, int selectFromDeck)
default Command	EditablePiece.prepareMove(Command c, boolean mark_moved)	Centralized method for preparing a piece to move.
default Command	GamePiece.prepareMove(Command c, boolean mark_moved)
Command	FreeRotator.rotateCargo(Command command, Point center, double dtheta)
void	Translate.MoveExecuter.setAdditionalCommand(Command c)

Constructors in VASSAL.counters with parameters of type Command

Modifier	Constructor	Description
	AttachVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	DetachVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	GlobalCommandVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck, GlobalCommand globalCommand)
	SetVisitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit, Auditable owner, int selectFromDeck)
	Visitor(Command command, PieceFilter filter, KeyStroke stroke)
	Visitor(Command command, PieceFilter filter, KeyStroke stroke, AuditTrail audit)

Uses of Command in VASSAL.property

Methods in VASSAL.property that return Command

Modifier and Type	Method	Description
Command	PersistentPropertyContainer.setPersistentProperty(Object key, Object val)	Setting a persistent property writes a property value into the piece (creating a new entry in the piece's persistent property table if the specified key does not yet exist in it).