Uses of Interface
VASSAL.counters.GamePiece

Packages that use GamePiece

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.index
VASSAL.build.module.map	Contains classes that may be added to a Map.
VASSAL.build.module.map.deck
VASSAL.build.module.properties
VASSAL.build.widget	Contains classes that can be added to a Widget.
VASSAL.command	Provides classes that implement the "Command" design pattern.
VASSAL.configure	Provides classes for building "Edit Property" dialogs, and for editing GameModule's and ModuleExtension's.
VASSAL.counters	Provides classes that define game pieces.
VASSAL.i18n
VASSAL.script
VASSAL.script.expression
VASSAL.script.proxy
VASSAL.tools.imageop
VASSAL.tools.imports.adc2

Uses of GamePiece in VASSAL.build

Methods in VASSAL.build that return GamePiece

Modifier and Type	Method	Description
GamePiece	GameModule.createPiece(String type)	Central location to create any type of GamePiece from within VASSAL
GamePiece	GameModule.createPiece(String type, GamePiece inner)	Central location to create any type of GamePiece Trait (Decorator) from within VASSAL
GamePiece	GpIdChecker.createUpdatedPiece(GamePiece oldPiece)	Locate the SlotElement that matches oldPiece and return a new GamePiece created from that Slot.

Methods in VASSAL.build with parameters of type GamePiece

Modifier and Type	Method	Description
protected void	GpIdChecker.checkTrait(GamePiece gp)	Check for PlaceMarker traits in a GamePiece and add them to the cross-reference
protected void	GpIdChecker.checkTrait(GamePiece gp, PrototypeDefinition prototype, GamePiece definition)
protected void	GpIdChecker.copyState(GamePiece oldPiece, GamePiece newPiece)	Copy as much state information as possible from the old piece to the new piece
GamePiece	GameModule.createPiece(String type, GamePiece inner)	Central location to create any type of GamePiece Trait (Decorator) from within VASSAL
GamePiece	GpIdChecker.createUpdatedPiece(GamePiece oldPiece)	Locate the SlotElement that matches oldPiece and return a new GamePiece created from that Slot.
protected String	GpIdChecker.findState(GamePiece oldPiece, GamePiece pNew, Decorator decoratorNewPc, Class<? extends GamePiece> classToFind)	Locate a Decorator in the old piece that has the exact same type as the new Decorator and return it's state

Method parameters in VASSAL.build with type arguments of type GamePiece

Modifier and Type	Method	Description
protected String	GpIdChecker.findState(GamePiece oldPiece, GamePiece pNew, Decorator decoratorNewPc, Class<? extends GamePiece> classToFind)	Locate a Decorator in the old piece that has the exact same type as the new Decorator and return it's state

Uses of GamePiece in VASSAL.build.module

Fields in VASSAL.build.module declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece	Inventory.Counter.piece
protected GamePiece	Inventory.Counter.source

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

Modifier and Type	Field	Description
protected Map<String,GamePiece>	GameState.pieces

Methods in VASSAL.build.module that return GamePiece

Modifier and Type	Method	Description
protected GamePiece	BasicCommandEncoder.createBasic(String type)	Create a GamePiece instance that is not a Decorator ("Trait").
GamePiece	BasicCommandEncoder.BasicPieceFactory.createBasicPiece(String type)
GamePiece	BasicCommandEncoder.createPiece(String type)	Creates a GamePiece instance from the given type information.
GamePiece	Map.findAnyPiece(Point pt, PieceFinder finder)	Use the provided PieceFinder instance to locate any piece at the given location, regardless of whether it is visible or not.
GamePiece	Map.findPiece(Point pt, PieceFinder finder)	Use the provided PieceFinder instance to locate a visible piece at the given location
GamePiece[]	Map.getAllPieces()
GamePiece	Inventory.Counter.getPiece()
GamePiece	PrototypeDefinition.getPiece()
protected GamePiece	PrototypeDefinition.getPiece(String def)
GamePiece	PrototypeDefinition.getPiece(PropertySource props)	For the case when the piece definition is a Message Format, expand the definition using the given properties
GamePiece	GameState.getPieceForId(String id)
GamePiece[]	Map.getPieces()
GamePiece	Inventory.getSelectedCounter()

Methods in VASSAL.build.module that return types with arguments of type GamePiece

Modifier and Type	Method	Description
Collection<GamePiece>	GameState.getAllPieces()
Enumeration<GamePiece>	GameState.getPieces()	Deprecated, for removal: This API element is subject to removal in a future version. Use GameState.getAllPieces() instead.
List<GamePiece>	Refresher.getRefreshedPieces()

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

Modifier and Type	Method	Description
boolean	Inventory.Selector.accept(GamePiece piece)
void	AttachmentManager.addPiece(GamePiece piece)	A piece has been added to the game. 1.
void	GameState.addPiece(GamePiece p)	Add a GamePiece to the current game.
void	Map.addPiece(GamePiece p)	Adds a GamePiece to this map's list of pieces.
Rectangle	Map.boundingBoxOf(GamePiece p)
Decorator	BasicCommandEncoder.createDecorator(String type, GamePiece inner)	Creates a Decorator instance - a GamePiece "Trait".
Decorator	BasicCommandEncoder.DecoratorFactory.createDecorator(String type, GamePiece inner)
protected int	Inventory.getTotalValue(GamePiece p)
void	GameRefresher.indexAttachment(GamePiece piece)	Index any attachments in this piece, storing a list of the attachments' contents, each under a hash made by taking the outermost piece's Unique ID and adding the notionally unique Attachment Name
int	Map.indexOf(GamePiece s)	Returns the index of a piece.
void	AttachmentManager.pieceAdded(GamePiece piece)
void	AttachmentManager.pieceRemoved(GamePiece piece)
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.
Point	Map.positionOf(GamePiece p)
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	Plugin.registerGamePiece(GamePiece p)	Utility routine to register a GamePiece with the PieceDefiner so that it appears as an option in the list of traits
Command	AttachmentManager.removeAttachments(GamePiece piece)	A piece is being removed by a Delete or Replace Command.
void	AttachmentManager.removePiece(GamePiece piece)	A piece has been removed from a Map.
void	GameState.removePiece(GamePiece piece)
void	Map.removePiece(GamePiece p)	Removes a piece from the map
Rectangle	Map.selectionBoundsOf(GamePiece p)
void	Inventory.Counter.setPiece(GamePiece piece)
void	PrototypeDefinition.Config.Definer.setPiece(GamePiece piece)
void	PrototypeDefinition.setPiece(GamePiece p)
Object	Map.Merger.visitDefault(GamePiece piece)

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

Modifier	Constructor	Description
	Counter(String name, GamePiece p)
	Counter(GamePiece piece, List<String> groups, int value, String format, String sortFormat)
	Merger(Map map, Point pt, GamePiece p)	Constructor for a Merger.

Uses of GamePiece in VASSAL.build.module.index

Methods in VASSAL.build.module.index that return types with arguments of type GamePiece

Modifier and Type	Method	Description
List<GamePiece>	IndexManager.getPieces(Map map, Point point)	Return a list of pieces at a specific point on a specific map
List<GamePiece>	IndexManager.getPieces(Map map, Point point, int range)
List<GamePiece>	IndexManager.getPieces(Map map, Point point, int range, boolean forceAsPixels)	Return a list of pieces within a given range of a specified point
List<GamePiece>	IndexManager.getPieces(Map map, String propertyName, String propertyValue)	Return a list of pieces on a Map with a specified value for the specified property
List<GamePiece>	IndexManager.getPieces(GamePiece piece, int range)
List<GamePiece>	IndexManager.getPieces(GamePiece piece, int range, boolean forceAsPixels)	Return a list of pieces within a given range of another piece
Set<GamePiece>	PiecePropertyIndex.getPieces(String propertyValue)	Return the set of pieces that have the specified value for the property we are indexing
List<GamePiece>	VassalMapPieceIndex.getPieces(Point point, int range)	Return a list of pieces in range of a given point.
List<GamePiece>	VassalMapPieceIndex.getPieces(Point point, int range, boolean forceAsPixels)	Return a list of pieces in range of a given point.
Set<GamePiece>	VassalMapPieceIndex.getPieces(String propertyName, String propertyValue)
List<GamePiece>	VassalMapPieceIndex.getPieces(GamePiece piece, int range)	Return a list of pieces in range of a given piece
List<GamePiece>	VassalMapPieceIndex.getPieces(GamePiece piece, int range, boolean forceAsPixels)
List<GamePiece>	VassalMapQuadTree.getPiecesInRange(Point pos, int range)	Return a list of all pieces within range of a given Point NOTE: This is just a pre-selection, we are seacrchign a box, not a circle so extra pieces will be returned that are not in range.

Methods in VASSAL.build.module.index with parameters of type GamePiece

Modifier and Type	Method	Description
void	PiecePropertyIndex.addOrUpdatePiece(GamePiece piece)	Add a new piece to the index, or check and update the value for an existing piece
void	VassalMapPieceIndex.addOrUpdatePiece(GamePiece piece)	A piece has been added to our map.
void	VassalMapQuadTree.addOrUpdatePiece(GamePiece p)	Add a piece to the Qtree, or change it's location
List<GamePiece>	IndexManager.getPieces(GamePiece piece, int range)
List<GamePiece>	IndexManager.getPieces(GamePiece piece, int range, boolean forceAsPixels)	Return a list of pieces within a given range of another piece
List<GamePiece>	VassalMapPieceIndex.getPieces(GamePiece piece, int range)	Return a list of pieces in range of a given piece
List<GamePiece>	VassalMapPieceIndex.getPieces(GamePiece piece, int range, boolean forceAsPixels)
void	IndexManager.pieceMoved(GamePiece piece, Map map)	A piece has just moved or been placed on the board, update any location based indexes and create any property based indexes if we have not seen this piece before
void	IndexManager.pieceRemoved(GamePiece piece, Map map)	A piece has been removed from a Map
void	PiecePropertyIndex.removePiece(GamePiece piece)	Remove a piece from the index
void	VassalMapPieceIndex.removePiece(GamePiece piece)	A piece has been removed from our map
void	VassalMapQuadTree.removePiece(GamePiece p)	Remove a piece from the Qtree and the cross-reference

Uses of GamePiece in VASSAL.build.module.map

Classes in VASSAL.build.module.map that implement interfaces with type arguments of type GamePiece

Modifier and Type	Class	Description
class	PieceMover	PieceMover handles the "Drag and Drop" of pieces and stacks, onto or within a Map window.

Fields in VASSAL.build.module.map declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece	KeyBufferer.bandSelectPiece
protected GamePiece	PieceMover.dragging
protected GamePiece	HighlightLastMoved.lastMoved
protected GamePiece	SetupStack.StackConfigurer.myPiece
protected GamePiece	SetupStack.View.myPiece

Fields in VASSAL.build.module.map with type parameters of type GamePiece

Modifier and Type	Field	Description
protected List<GamePiece>	CounterDetailViewer.displayablePieces
protected List<GamePiece>	CounterDetailViewer.Visitor.pieces
protected List<GamePiece>	MovementReporter.MoveSummary.pieces
protected Comparator<GamePiece>	PieceMover.pieceSorter

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

Modifier and Type	Method	Description
GamePiece[]	CompoundPieceCollection.getAllPieces()
GamePiece[]	PieceCollection.getAllPieces()	Return all pieces in the collection, regardless of visibility
GamePiece[]	SimplePieceCollection.getAllPieces()
GamePiece[]	CompoundPieceCollection.getPieces()
protected GamePiece[]	CompoundPieceCollection.getPieces(boolean includeDisabled)
GamePiece[]	PieceCollection.getPieces()	Return all currently-visible pieces in the collection as a read-only array
GamePiece[]	SimplePieceCollection.getPieces()

Methods in VASSAL.build.module.map that return types with arguments of type GamePiece

Modifier and Type	Method	Description
protected List<GamePiece>	CounterDetailViewer.getDisplayablePieces()	Build an ArrayList of pieces to be displayed in order from bottom up, based on selection criteria setup in config.
protected List<GamePiece>	GlobalMap.CounterViewer.getDisplayablePieces()
List<GamePiece>	CounterDetailViewer.Visitor.getPieces()

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

Modifier and Type	Method	Description
boolean	CounterDetailViewer.Filter.accept(GamePiece piece)
boolean	CounterDetailViewer.Filter.accept(GamePiece piece, int layer, String layerName)
protected boolean	SelectionHighlighter.accept(GamePiece p)
void	CompoundPieceCollection.add(GamePiece p)	Adds a piece to the overall collection, by adding it to the simple collection for the layer it belongs in.
void	PieceCollection.add(GamePiece p)	Adds a piece
void	SimplePieceCollection.add(GamePiece p)
Command	DrawPile.addToContents(GamePiece p)
Command	DrawPile.addToContents(GamePiece p, boolean checkAccessibility)
protected void	CounterDetailViewer.Visitor.apply(GamePiece p)
Rectangle	SelectionHighlighter.boundingBox(GamePiece p)
boolean	CompoundPieceCollection.canMerge(GamePiece p1, GamePiece p2)	Used when moving a piece on top of another piece to determine whether they can be merged together (e.g. can this Piece be added to that Stack, can this Stack be added to that Deck, can these two Stacks be combined together into one).
boolean	PieceCollection.canMerge(GamePiece p1, GamePiece p2)	Return true if the two pieces can be merged into a single stack
boolean	SimplePieceCollection.canMerge(GamePiece p1, GamePiece p2)
protected boolean	CompoundPieceCollection.canPiecesMerge(GamePiece p1, GamePiece p2)	Two pieces can merge in the default case as long as neither is presently invisible and neither has a Does Not Stack (Hideable) trait.
protected boolean	LayeredPieceCollection.Collection.canPiecesMerge(GamePiece p1, GamePiece p2)
protected boolean	CompoundPieceCollection.canStackAndPieceMerge(Stack s, GamePiece p)	A piece can be merged into a stack if it is merge-compatible with the first piece in the stack.
boolean	CounterDetailViewer.Filter.checkFilter(GamePiece piece)
protected void	MapShader.checkPiece(Area area, GamePiece piece)
Command	PieceMover.checkTrueMoved(GamePiece p)	For a piece, mark it moved IF it changed locations or mats
int	PieceMover.compare(GamePiece p1, GamePiece p2)	Implement Comparator to sort the contents of the drag buffer before completing the drag.
static JPopupMenu	MenuDisplayer.createPopup(GamePiece target)
static JPopupMenu	MenuDisplayer.createPopup(GamePiece target, boolean global)
Stack	StackMetrics.createStack(GamePiece p)
Stack	StackMetrics.createStack(GamePiece p, boolean force)
void	SelectionHighlighter.draw(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
protected void	StackMetrics.drawUnexpanded(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)	Draw a GamePiece that is not the top piece in an unexpanded Stack Default implementation is a white square with a black border
protected Rectangle	CounterDetailViewer.getBounds(GamePiece piece)
protected PieceCollection	CompoundPieceCollection.getCollectionForPiece(GamePiece p)	Given a game piece, returns the simple piece collection for the layer that it belongs in
protected PieceFinder	PieceMover.getDropTargetSelector(GamePiece piece, MatCargo cargo, Mat mat)	Return a DropTargetSelector suitable for the type of piece being moved When the user *completes* a drag-and-drop operation, the pieces being dragged will either be: (1) combined in a stack with an existing piece (or stack, or deck) on the map (2) placed alone in a brand new stack (3) or, in the case of non-stacking pieces, placed on the map without stack.
int	CompoundPieceCollection.getLayerForPiece(GamePiece p)	Default implementation is "degenerate", having only a single layer -- when extending this class, this method takes a piece and determines which of several layers it belongs in, returning an index.
int	DefaultPieceCollection.getLayerForPiece(GamePiece p)
int	LayeredPieceCollection.Collection.getLayerForPiece(GamePiece p)	Gets the appropriate layer for the given piece (or Stack or Deck).
String	CompoundPieceCollection.getLayerNameForPiece(GamePiece p)	Default implementation is "degenerate", having only a single layer -- when extending this class, this method takes a piece and determines which of several layers it belongs in, returning the layer name.
String	LayeredPieceCollection.Collection.getLayerNameForPiece(GamePiece p)
int	CompoundPieceCollection.indexOf(GamePiece p)
int	PieceCollection.indexOf(GamePiece p)	Returns the index of a piece.
int	SimplePieceCollection.indexOf(GamePiece p)	Returns the index of a piece.
protected boolean	MovementReporter.HiddenMoveSummary.isInvisible(GamePiece piece)
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	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.
void	CompoundPieceCollection.moveToBack(GamePiece p)
void	PieceCollection.moveToBack(GamePiece p)	Reposition a piece to the back of all others in the same visual layer
void	SimplePieceCollection.moveToBack(GamePiece p)
void	CompoundPieceCollection.moveToFront(GamePiece p)
void	PieceCollection.moveToFront(GamePiece p)	Reposition a piece to the front of all others in the same visual layer
void	SimplePieceCollection.moveToFront(GamePiece p)
Command	StackMetrics.placeOrMerge(GamePiece fixed, GamePiece moving)	Merge the two pieces if stacking is enabled.
Point	StackMetrics.relativePosition(Stack parent, GamePiece c)
void	CompoundPieceCollection.remove(GamePiece p)
void	PieceCollection.remove(GamePiece p)	Removes the piece
void	SimplePieceCollection.remove(GamePiece p)
void	SimplePieceCollection.reposition(GamePiece p, int pos)
static void	HighlightLastMoved.setLastMoved(GamePiece p)
void	HighlightLastMoved.setLastMovedPiece(GamePiece p)
protected Command	PieceMover.setOldLocations(GamePiece p)	Populates the "OldLocations" properties (e.g.
Object	CounterDetailViewer.Visitor.visitDefault(GamePiece p)
Object	KeyBufferer.KBDeckVisitor.visitDefault(GamePiece p)	Handles non-stacked units, including Does Not Stack units.
Object	LayeredPieceCollection.Collection.visitDefault(GamePiece p)	Ordinary pieces are queried for their value of the designated layer property, and this value is then checked against the list of layer names.
Object	PieceRecenterer.visitDefault(GamePiece p)	Implements DeckVisitor.

Method parameters in VASSAL.build.module.map with type arguments of type GamePiece

Modifier and Type	Method	Description
protected Command	PieceMover.applyKeyAfterMove(List<GamePiece> pieces, KeyStroke key)	Applies a key command to each of a list of pieces.
protected Command	PieceMover.doTrueMovedSupport(List<GamePiece> pieces)	For a list of pieces, mark them moved IF they changed locations or mats
protected void	CounterDetailViewer.drawGraphics(Graphics g, Point pt, JComponent comp, List<GamePiece> pieces)
protected void	CounterDetailViewer.drawText(Graphics g, Point pt, JComponent comp, List<GamePiece> pieces)	Label with the location If the counter viewer is being displayed, then place the location name just above the left hand end of the counters.
protected void	CounterDetailViewer.fixBounds(List<GamePiece> pieces)
protected void	CounterDetailViewer.fixBounds(List<GamePiece> pieces, Graphics g)	Set the bounds field large enough to accommodate the given set of pieces

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

Modifier	Constructor	Description
	DeckPolicyConfig(boolean showPrompt, GamePiece sourcePiece)

Uses of GamePiece in VASSAL.build.module.map.deck

Classes in VASSAL.build.module.map.deck that implement interfaces with type arguments of type GamePiece

Modifier and Type	Class	Description
class	SortParameterComparator	Compare 2 GamePieces based on a List of SortParameters

Methods in VASSAL.build.module.map.deck with parameters of type GamePiece

Modifier and Type	Method	Description
int	SortParameterComparator.compare(GamePiece piece1, GamePiece piece2)

Uses of GamePiece in VASSAL.build.module.properties

Fields in VASSAL.build.module.properties with type parameters of type GamePiece

Modifier and Type	Field	Description
protected Collection<GamePiece>	SumProperties.pieces

Constructor parameters in VASSAL.build.module.properties with type arguments of type GamePiece

Modifier	Constructor	Description
	SumProperties(Collection<GamePiece> pieces)

Uses of GamePiece in VASSAL.build.widget

Fields in VASSAL.build.widget declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece	PieceSlot.c
protected GamePiece	PieceSlot.expanded

Methods in VASSAL.build.widget that return GamePiece

Modifier and Type	Method	Description
protected GamePiece	PieceSlot.getExpandedPiece()	Return defined GamePiece with prototypes fully expanded.
GamePiece	PieceSlot.getPiece()	Return defined GamePiece with prototypes unexpanded.

Methods in VASSAL.build.widget with parameters of type GamePiece

Modifier and Type	Method	Description
void	PieceSlot.setPiece(GamePiece p)
void	PieceSlot.updateGpId(GamePiece piece)	Allocate new gpids in the given GamePiece

Constructors in VASSAL.build.widget with parameters of type GamePiece

Modifier	Constructor	Description
	PieceSlot(GamePiece p)

Uses of GamePiece in VASSAL.command

Methods in VASSAL.command that return GamePiece

Modifier and Type	Method	Description
GamePiece	AddPiece.getTarget()
GamePiece	RemovePiece.getTarget()

Methods in VASSAL.command with parameters of type GamePiece

Modifier and Type	Method	Description
protected PieceVisitorDispatcher	MovePiece.createMergeFinder(Map map, GamePiece p, Point pt)	Creates a new PieceVisitorDispatcher that will create a Command object to merge the target piece with any applicable pieces at the target location

Constructors in VASSAL.command with parameters of type GamePiece

Modifier	Constructor	Description
	AddPiece(GamePiece p)
	AddPiece(GamePiece p, String state)
	ChangeTracker(GamePiece p)
	MoveTracker(GamePiece piece)
	RemovePiece(GamePiece p)

Uses of GamePiece in VASSAL.configure

Fields in VASSAL.configure declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece	FormattedStringArrayConfigurer.target

Methods in VASSAL.configure with parameters of type GamePiece

Modifier and Type	Method	Description
boolean	PropertyExpression.accept(PropertySource source, GamePiece piece)
boolean	PropertyExpression.accept(PropertySource source, GamePiece piece, Auditable owner, AuditTrail trail)
boolean	PropertyExpression.accept(GamePiece piece)
boolean	PropertyExpression.accept(GamePiece source, GamePiece piece)
boolean	PropertyExpression.accept(GamePiece source, GamePiece piece, Auditable owner, AuditTrail trail)
boolean	PropertyExpression.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	PropertyExpression.accept(GamePiece piece, Auditable owner, AuditTrail audit)
protected void	FormattedExpressionConfigurer.storePiece(GamePiece p)

Constructors in VASSAL.configure with parameters of type GamePiece

Modifier	Constructor	Description
	BeanShellExpressionConfigurer(String key, String name, String val, GamePiece piece)	Create a labeled BeanShellConfigurer with an initial value and target piece
	BeanShellExpressionConfigurer(String key, String name, String val, GamePiece piece, BeanShellExpressionConfigurer.Option option)
	BeanShellExpressionConfigurer(String key, String name, String val, GamePiece piece, BeanShellExpressionConfigurer.Option option, boolean displayOnly)
	BeanShellExpressionConfigurer(String key, String name, String val, GamePiece piece, BeanShellExpressionConfigurer.Option option, FunctionBuilder builder)
	BeanShellExpressionConfigurer(String val, GamePiece piece)	Create an unlabeled BeanShellConfigurer with an initial value and target piece
	DeckSelectionConfigurer(String s, GamePiece p)
	FormattedExpressionConfigurer(String key, String name, String s, GamePiece p)
	FormattedExpressionConfigurer(String s, GamePiece p)
	FormattedStringArrayConfigurer(String key, String name, GamePiece target)
	GlobalCommandTargetConfigurer(GlobalCommandTarget target, GamePiece sourcePiece)
	PlayerIdFormattedExpressionConfigurer(String[] options, String initialValue, GamePiece piece)
	PropertyExpressionConfigurer(String key, String name, String val, GamePiece piece)
	PropertyExpressionConfigurer(String key, String name, PropertyExpression val, GamePiece piece)
	PropertyExpressionConfigurer(PropertyExpression val, GamePiece piece)
	PropertyNameExpressionConfigurer(String key, String name, String val, GamePiece piece)
	PropertyNameExpressionConfigurer(String key, String name, PropertyExpression val, GamePiece piece)

Uses of GamePiece in VASSAL.counters

Subinterfaces of GamePiece in VASSAL.counters

Modifier and Type	Interface	Description
interface	EditablePiece	If class implementing GamePiece also implements the EditablePiece interface, then it can be manipulated from the Editor's Configuration Tree via the PieceDefiner dialog.

Classes in VASSAL.counters that implement GamePiece

Modifier and Type	Class	Description
class	ActionButton	A Trait (aka Decorator that acts like a button on a GamePiece, such that clicking on a particular area of the piece invokes a key command
class	AreaOfEffect
class	Attachment	Trait allowing creation of an "attachment" to one or more other pieces, which can then be sent GKCs very swiftly and whose properties can be easily read (and if a Dynamic Property can also be set with a Set Global Property trait)
class	BasicName	This trait overrides the $BasicName$ property provided by the "Basic Piece", allowing a module designer decking to define pieces entirely by prototype to safely ignore and leave empty the Basic Piece.
class	BasicPiece	Basic class for representing a physical component of the game.
class	BorderOutline	Trait to draw a colored border around a piece
class	CalculatedProperty	Conditional Marker A marker with a variable value depending on conditions.
class	Clone	This trait adds a command that creates a duplicate of the selected Gamepiece
class	Comment	A trait that exists in a Piece Definition, but is not included when the piece is created in a real game.
class	CounterGlobalKeyCommand	Trait that sends a Key Command to other pieces, selected with various filters.
class	Deck	A collection of pieces that behaves like a deck, i.e.: Doesn't move.
class	Decorator	The abstract class describing a generic 'Trait' of a full GamePiece.
class	Delete	This trait adds a command that creates a duplicate of the selected Gamepiece
class	Deselect	Implements a trait to allow a piece to be deselected from the KeyBuffer in response to a Key Command.
class	DynamicProperty	Trait that contains a property accessible via getProperty() and updatable dynamically via key commands
class	Embellishment	d/b/a "Layer" The "Layer" trait.
class	Embellishment0	Embellishment has been extensively re-written for Vassal 3.2 changing both the behavior and the visual look of the configurer.
class	Footprint	Displays a movement trail indicating where a piece has been moved
class	FreeRotator	d/b/a "Can Rotate" A Decorator that rotates a GamePiece to an arbitrary angle
class	GlobalHotKey	Adds a menu entry that fires a specified key event to the module window.
class	Hideable
class	Immobilized	d/b/a "Does Not Stack" Decorator that filters events to prevent a GamePiece from being selected and/or moved.
class	Labeler	d/b/a "Text Label" Displays a text label, with content specified by the user at runtime.
class	Marker	A generic Decorator that retains in its state the value of a property.
class	Mat	Designates the piece as a "Mat" on which other pieces ("Cargo") can be placed.
class	MatCargo	Designates the piece as "Cargo", which can be placed on a "Mat" to move along with it
class	MenuSeparator	This trait puts a menu separator bar in the context menu for the piece
class	MovementMarkable	d/b/a "Mark When Moved" A GamePiece with this trait will automatically be marked whenever it is moved.
class	MultiLocationCommand	Allows a single trait to generate multiple context menu commands, using a set of filtered map locations.
class	NonRectangular	A trait for assigning an arbitrary shape to a GamePiece
class	Obscurable	d/b/a "Mask" Trait that lets some traits of a piece be hidden "from some players, some of the time".
class	Pivot	d/b/a "Can Pivot" Provides commands to pivot a Game Piece around a given point
class	PlaceMarker	This Decorator defines a key command to places another counter on the same map as this one, normally on top but stack adjustment and offsets may be specified too.
class	PlaySound	A trait that plays a sound clip
class	PropertySheet	A Decorator class that endows a GamePiece with a dialog.
class	Replace	GamePiece trait that replaces a GamePiece with another one
class	ReportState	d/b/a "Report Action" A GamePiece with this trait will echo the piece's current name when any of a given key commands are pressed (and after they take effect)
class	RestrictCommands	RestrictCommands Restrict the availability of Key Commands, depending on a Property Match String
class	Restricted	d/b/a "Restricted Access" A GamePiece with the Restricted trait can only be manipulated by the player playing a specific side
class	ReturnToDeck	GamePiece trait that returns a piece to a DrawPile
class	SendToLocation	This trait adds a command that sends a piece to another location.
class	SetGlobalProperty
class	SetPieceProperty
class	Stack	A Stack is a collection of pieces in the same location that can often be moved with a single drag-and-drop.
class	SubMenu	A trait that groups menu items of other traits into a sub-menu
class	TableInfo	d/b/a "Spreadsheet" A Decorator class that endows a GamePiece with an editable spreadsheet (i.e.
class	TranslatableMessage	A trait to expose a translated string as a readable/displayable property.
class	Translate	d/b/a "Move Fixed Distance" Give a piece a command that moves it a fixed amount in a particular direction, optionally tracking the current rotation of the piece.
class	TriggerAction	Macro Execute a series of Keystrokes against this same piece - Triggered by own KeyCommand or list of keystrokes - Match against an optional Property Filter
class	UsePrototype	d/b/a "Prototype" This trait is a placeholder for a pre-defined series of traits specified in a PrototypeDefinition object.

Classes in VASSAL.counters that implement interfaces with type arguments of type GamePiece

Modifier and Type	Class	Description
class	PieceSorter	Sorts GamePieces according to their position: If on different Maps, order by Map id If in different Stacks order by Stack position on the Map If in the same Stack, order by position within the Stack

Fields in VASSAL.counters declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece[]	Stack.contents
protected GamePiece	MatCargo.mat
protected GamePiece	Obscurable.obscuredToMeView
protected GamePiece	Obscurable.obscuredToOthersView
protected GamePiece	TriggerAction.outer
protected GamePiece	Decorator.piece

Fields in VASSAL.counters with type parameters of type GamePiece

Modifier and Type	Field	Description
protected JList<GamePiece>	PieceDefiner.availableList
protected static DefaultListModel<GamePiece>	PieceDefiner.availableModel
protected ListCellRenderer<? super GamePiece>	PieceDefiner.availableRenderer
protected List<GamePiece>	Attachment.contents
protected List<GamePiece>	Mat.contents
protected DefaultListModel<GamePiece>	PieceDefiner.inUseModel
protected List<GamePiece>	Deck.nextDraw
protected ListCellRenderer<? super GamePiece>	PieceDefiner.r
static final Predicate<GamePiece>	PieceIterator.VISIBLE

Methods in VASSAL.counters with type parameters of type GamePiece

Modifier and Type	Method	Description
static <T extends GamePiece> PieceIterator	PieceIterator.visible(Enumeration<T> e)	Deprecated, for removal: This API element is subject to removal in a future version.
static <T extends GamePiece> PieceIterator	PieceIterator.visible(Iterator<T> i)

Methods in VASSAL.counters that return GamePiece

Modifier and Type	Method	Description
GamePiece	Stack.bottomPiece()
GamePiece	Stack.bottomPiece(String playerId)
GamePiece	PieceCloner.clonePiece(GamePiece piece)	Create a new instance that is a clone of the given piece.
GamePiece	PieceCloner.clonePiece(GamePiece piece, boolean expandPiece)
GamePiece	PieceCloner.clonePieceUnexpanded(GamePiece piece)	Create a new instance that is a clone of the given piece.
GamePiece	PlaceMarker.createBaseMarker()	The marker, with prototypes unexpanded
GamePiece	PlaceMarker.createMarker()	The marker, with prototypes fully expanded
GamePiece	Replace.createMarker()
protected GamePiece	Translate.findTarget(KeyStroke stroke)
GamePiece	Attachment.getAttachedPieceAt(int index)
GamePiece	GlobalCommandTarget.getCurPiece()
static GamePiece	Decorator.getDecorator(GamePiece p, Class<?> type)
GamePiece	UsePrototype.getExpandedInner()	Build a new GamePiece instance based on the traits in the referenced PrototypeDefinition.
GamePiece	Decorator.getInner()
static GamePiece	Decorator.getInnermost(GamePiece p)
GamePiece	MatCargo.getMat()
GamePiece	MatHolder.getMatPiece()
GamePiece	ReportState.OldAndNewPieceProperties.getNewPiece()
static GamePiece	Decorator.getOutermost(GamePiece p)
GamePiece	PieceDefiner.getPiece()
GamePiece	Stack.getPieceAbove(GamePiece p)	Finds the piece "above" the one provided
GamePiece	Stack.getPieceAt(int index)
GamePiece	Stack.getPieceBeneath(GamePiece p)	Finds the piece "underneath" the one provided
GamePiece	Attachment.getPropertyPiece()
GamePiece	KeyCommand.getTarget()
GamePiece	MatCargo.locateNewMat(Map map, Point pt)	Non Command generating part of findNewMat().
GamePiece	PieceIterator.nextPiece()
protected GamePiece	PieceDefiner.removeDecorator(int index)	Remove the Decorator at a given position in the list
GamePiece	PieceFinder.Movable.select(Map map, GamePiece piece, Point pt)
GamePiece	PieceFinder.select(Map map, GamePiece piece, Point pt)	Return the argument GamePiece (or one of its children if a Stack) found at the given point on the given Map
GamePiece	Stack.topPiece()	CAUTION: returns the top VISIBLE piece in the stack, or null if none is visible.
GamePiece	Stack.topPiece(String playerId)

Methods in VASSAL.counters that return types with arguments of type GamePiece

Modifier and Type	Method	Description
List<GamePiece>	DragBuffer.asList()
List<GamePiece>	KeyBuffer.asList()	Returns a list of all selected pieces.
List<GamePiece>	Stack.asList()	A list of the pieces in the stack.
List<GamePiece>	Attachment.getAttachList()
static List<GamePiece>	Attachment.getAttachList(GamePiece piece, String attachmentName)	Return the named attachment list on the supplied GamePiece
List<GamePiece>	MatHolder.getCargo()
List<GamePiece>	Attachment.getContents()
List<GamePiece>	Mat.getContents()
static List<GamePiece>	Decorator.getDecorators(GamePiece p, Class<?> type)
List<GamePiece>	Deck.getOrderedPieces()	Return a list if pieces in the Deck in Dealable order.
Enumeration<GamePiece>	KeyBuffer.getPieces()	Deprecated, for removal: This API element is subject to removal in a future version. Use KeyBuffer.getPiecesIterator() instead.
Enumeration<GamePiece>	Stack.getPieces()	Deprecated, for removal: This API element is subject to removal in a future version. use Stack.asList()
Iterator<GamePiece>	Stack.getPiecesInVisibleOrderIterator()	Returns pieces in the order in which they are visible to the player -- topmost first In other words, selected pieces first, then unselected pieces from the top to the bottom.
Iterator<GamePiece>	KeyBuffer.getPiecesIterator()	Returns an iterator for all selected pieces.
Iterator<GamePiece>	Stack.getPiecesIterator()
Iterator<GamePiece>	Stack.getPiecesReverseIterator()
List<GamePiece>	PieceDefiner.getTraitList()	Export a List of all the allowable traits
static List<GamePiece>	ActionButton.matchingTraits(GamePiece p, Point point)	Finds all the ActionButton traits within a game piece which mouse a particular mouse stroke

Methods in VASSAL.counters with parameters of type GamePiece

Modifier and Type	Method	Description
boolean	BooleanAndPieceFilter.accept(GamePiece piece)	Deprecated. Use BooleanAndPieceFilter.accept(GamePiece, Auditable, String)
boolean	BooleanAndPieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BooleanAndPieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)
boolean	BooleanOrPieceFilter.accept(GamePiece piece)	Deprecated.
boolean	BooleanOrPieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BooleanOrPieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)
Object	DeckVisitorDispatcher.accept(GamePiece piece)
void	GlobalCommand.IndexedFastmatchDeckPolicyManager.accept(GamePiece piece, DeckVisitorDispatcher dispatcher, GlobalCommandVisitor visitor)	If a piece resides in a Deck, check if the Deck acceptance limit has been reached for that particular Deck before running the piece through the dispatcher.
boolean	PieceFilter.accept(GamePiece piece)	Test if a piece matches the filter.
default boolean	PieceFilter.accept(GamePiece piece, Auditable owner, String fieldKey)	Test if a piece matches the filter and provide Expression auditing facilities
default boolean	PieceFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)	Test if a piece matches the filter and provide Expression auditing facilities
Object	PieceVisitorDispatcher.accept(GamePiece piece)
boolean	RangeFilter.accept(GamePiece piece)
void	DragBuffer.add(GamePiece p)
void	KeyBuffer.add(GamePiece p)	Adding a piece to the KeyBuffer "selects the piece" (and lets it know about in its SELECTED property)
void	Stack.add(GamePiece c)	Adds a piece to the stack.
void	Translate.MoveExecuter.add(Map map, GamePiece piece, Point pos)
void	Mat.addCargo(GamePiece p)	Adds a piece of cargo to this mat
static void	PieceDefiner.addDefinition(GamePiece definition)	Plugins can add additional GamePiece definitions
protected static void	PieceDefiner.addElement(GamePiece piece)
void	KeyBuffer.addFromPalette(GamePiece p, PieceSlot slot)
void	Translate.MoveExecuter.addKeyEventTarget(GamePiece piece)
void	BoundsTracker.addPiece(GamePiece p)
protected void	GlobalAttach.AttachVisitor.apply(GamePiece p, boolean visitingDeck)
protected void	GlobalCommandVisitor.apply(GamePiece p)
protected void	GlobalCommandVisitor.apply(GamePiece p, boolean visitingDeck)
protected void	GlobalDetach.DetachVisitor.apply(GamePiece p, boolean visitingDeck)
protected void	GlobalSetter.SetVisitor.apply(GamePiece p, boolean visitingDeck)
Rectangle	ColoredBorder.boundingBox(GamePiece p)
Rectangle	Highlighter.boundingBox(GamePiece p)
GamePiece	PieceCloner.clonePiece(GamePiece piece)	Create a new instance that is a clone of the given piece.
GamePiece	PieceCloner.clonePiece(GamePiece piece, boolean expandPiece)
GamePiece	PieceCloner.clonePieceUnexpanded(GamePiece piece)	Create a new instance that is a clone of the given piece.
int	PieceSorter.compare(GamePiece p1, GamePiece p2)
boolean	DragBuffer.contains(GamePiece p)
boolean	KeyBuffer.contains(GamePiece p)	Tells if a particular piece is selected (i.e. present in the KeyBuffer)
void	ActionButton.ButtonPusher.doClick(GamePiece p, Point point)	Handle a mouse click on the given GamePiece at the given location (where 0,0 is the center of the piece).
void	ColoredBorder.draw(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
void	Highlighter.draw(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
boolean	BasicPiece.equals(GamePiece c)
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)
static List<GamePiece>	Attachment.getAttachList(GamePiece piece, String attachmentName)	Return the named attachment list on the supplied GamePiece
static GamePiece	Decorator.getDecorator(GamePiece p, Class<?> type)
static List<GamePiece>	Decorator.getDecorators(GamePiece p, Class<?> type)
static GamePiece	Decorator.getInnermost(GamePiece p)
static Embellishment	Embellishment.getLayerWithMatchingActivateCommand(GamePiece piece, KeyStroke stroke, boolean active)	If the argument GamePiece contains a Layer whose "activate" command matches the given keystroke, and whose active status matches the boolean argument, return that Layer
static Embellishment	Embellishment.getLayerWithMatchingActivateCommand(GamePiece piece, NamedKeyStroke stroke, boolean active)
static Embellishment	Embellishment0.getLayerWithMatchingActivateCommand(GamePiece piece, KeyStroke stroke, boolean active)	If the argument GamePiece contains a Layer whose "activate" command matches the given keystroke, and whose active status matches the boolean argument, return that Layer
static GamePiece	Decorator.getOutermost(GamePiece p)
GamePiece	Stack.getPieceAbove(GamePiece p)	Finds the piece "above" the one provided
GamePiece	Stack.getPieceBeneath(GamePiece p)	Finds the piece "underneath" the one provided
PieceSlot	KeyBuffer.getSlotForPiece(GamePiece piece)
Point	Translate.MoveExecuter.getUpdatedPosition(GamePiece target)	Return the updated position of a piece that has a move calculation recorded
boolean	Mat.hasCargo(GamePiece p)
boolean	Attachment.hasTarget(GamePiece p)
protected void	ColoredBorder.highlightSelectionBounds(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
int	Stack.indexOf(GamePiece p)	Finds the index of a piece in the stack
void	Stack.insert(GamePiece p, int pos)	Inserts a child GamePiece at a given index.
void	Stack.insertChild(GamePiece child, int index)	Adds a GamePiece to this Stack.
protected void	PieceDefiner.insertDecorator(int index, GamePiece piece)	Insert a Decorator into the list at a given position
protected void	Deck.insertPieceAt(GamePiece p, int index)	Inserts a piece into a specific position into the Deck (counting down from the top)
protected void	Deck.insertPieceAt(GamePiece p, int index, boolean suppressDeckCounts)	Inserts a piece into a specific position into the Deck (counting down from the top)
protected void	Stack.insertPieceAt(GamePiece p, int index)	Insert a piece at a particular point in the stack
protected void	Stack.insertPieceAt(GamePiece p, int index, boolean suppressDeckCounts)	Insert a piece at a particular point in the stack
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	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.
static List<GamePiece>	ActionButton.matchingTraits(GamePiece p, Point point)	Finds all the ActionButton traits within a game piece which mouse a particular mouse stroke
protected void	Replace.matchTraits(GamePiece base, GamePiece marker)	Match trait states from the supplied base Decorator to the marker - Markers are never matched - Dynamic Properties are matched on Name only - All other traits matched on full Type
boolean	Deck.mayContain(GamePiece piece)	Does the specified GamePiece meet the rules to be contained in this Deck.
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)
protected Point	SendToLocation.offsetDestination(int x, int y, GamePiece outer)
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
static Command	Decorator.putOldProperties(GamePiece p)	* Set the Oldxxxx properties related to movement (e.g.
void	ActionButton.ButtonPusher.register(Component obs, GamePiece piece, int x, int y)	Deprecated, for removal: This API element is subject to removal in a future version.
void	DragBuffer.remove(GamePiece p)
void	KeyBuffer.remove(GamePiece p)	Deselect the specified piece -- removes it from the KeyBuffer
void	Stack.remove(GamePiece p)
void	Mat.removeCargo(GamePiece p)	Removes a MatCargo piece from our list of cargo.
void	KeyBuffer.removeFromPalette(GamePiece p, PieceSlot slot)	Deselects a palette piece, repainting its palette slot
void	Attachment.removeTarget(GamePiece p)	Removes a piece from our list of targets
GamePiece	PieceFinder.Movable.select(Map map, GamePiece piece, Point pt)
GamePiece	PieceFinder.select(Map map, GamePiece piece, Point pt)	Return the argument GamePiece (or one of its children if a Stack) found at the given point on the given Map
protected void	PlaceMarker.selectMarker(GamePiece marker)
protected void	Replace.selectMarker(GamePiece marker)
void	Stack.selectNext(GamePiece c)	Finds and selects (in the UI) the next piece in the stack after this one
void	GlobalCommandTarget.setCurPiece(GamePiece curPiece)
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
void	Decorator.setInner(GamePiece p)
void	FreeRotator.setInner(GamePiece p)
void	UsePrototype.setInner(GamePiece p)
void	MatCargo.setMat(GamePiece mat)	Mark us as being on a specific Mat piece
void	PieceDefiner.setPiece(GamePiece piece)
Object	GlobalCommand.Visitor.visitDefault(GamePiece p)
Object	GlobalCommandVisitor.visitDefault(GamePiece p)
Object	PieceFinder.MatOnly.visitDefault(GamePiece piece)
Object	PieceFinder.Movable.visitDefault(GamePiece piece)
Object	PieceFinder.StackOnly.visitDefault(GamePiece piece)
Object	PieceVisitor.visitDefault(GamePiece p)	GamePieces that are not handled by one of the type-specific methods (e.g.

Method parameters in VASSAL.counters with type arguments of type GamePiece

Modifier and Type	Method	Description
protected void	GlobalCommand.checkForMatchingAttachments(Attachment attach, String attachmentName, String attachmentId, Set<GamePiece> pieces)
void	MatHolder.grabCargo(List<GamePiece> allCargo)	Remove any cargo on this mat from the supplied allCargo list and add to the MatHolders cargo list
void	MatHolder.setCargo(List<GamePiece> cargo)
void	Attachment.setContents(List<GamePiece> newContents)
Command	Deck.setContents(Collection<GamePiece> c)	Set the contents of this Deck to a Collection of GamePieces
void	DragBuffer.sort(Comparator<GamePiece> comp)
void	KeyBuffer.sort(Comparator<GamePiece> comp)	Sorts the selected pieces based on a particular Comparator

Constructors in VASSAL.counters with parameters of type GamePiece

Modifier	Constructor	Description
	ActionButton(String type, GamePiece inner)
	AreaOfEffect(String type, GamePiece inner)
	Attachment(String type, GamePiece inner)
	BasicName(String type, GamePiece inner)
	BorderOutline(String type, GamePiece p)
	CalculatedProperty(String type, GamePiece inner)
	Clone(String type, GamePiece inner)
	Comment(String type, GamePiece inner)
	ComponentMouseListener(GamePiece piece, int x, int y)	Deprecated, for removal: This API element is subject to removal in a future version.
	CounterGlobalKeyCommand(String type, GamePiece inner)
	Delete(String type, GamePiece inner)
	Deselect(String type, GamePiece inner)
	DynamicKeyCommand(String name, NamedKeyStroke key, GamePiece target, TranslatablePiece i18nPiece, PropertyChanger propChanger)
	DynamicProperty(String type, GamePiece p)
	Embellishment(String type, GamePiece d)
	Embellishment0(String type, GamePiece d)
	Footprint(String type, GamePiece p)
	FreeRotator(String type, GamePiece inner)
	GlobalHotKey(String type, GamePiece inner)
	Hideable(String type, GamePiece p)
	Immobilized(String type, GamePiece p)
	Immobilized(GamePiece p, String type)	Deprecated, for removal: This API element is subject to removal in a future version. Use Immobilized(String, GamePiece) instead.
	KeyCommand(String name, KeyStroke key, GamePiece target)
	KeyCommand(String name, KeyStroke key, GamePiece target, boolean enabled)
	KeyCommand(String name, KeyStroke key, GamePiece target, TranslatablePiece i18nPiece)
	KeyCommand(String name, KeyStroke key, GamePiece target, TranslatablePiece i18nPiece, boolean enabled)
	KeyCommand(String name, NamedKeyStroke key, GamePiece target)
	KeyCommand(String name, NamedKeyStroke key, GamePiece target, boolean enabled)
	KeyCommand(String name, NamedKeyStroke key, GamePiece target, TranslatablePiece i18nPiece)
	KeyCommand(String name, NamedKeyStroke key, GamePiece target, TranslatablePiece i18nPiece, boolean enabled)
	KeyCommandSubMenu(String name, GamePiece target, TranslatablePiece i18nPiece)
	Labeler(String s, GamePiece d)
	Marker(String type, GamePiece p)
	Mat(String type, GamePiece inner)
	MatCargo(String type, GamePiece inner)
	MatHolder(GamePiece piece)
	MenuSeparator(String type, GamePiece inner)
	MovementMarkable(String type, GamePiece p)
	MultiLocationCommand(String type, GamePiece inner)
	MultiLocationKeyCommand(String name, NamedKeyStroke key, GamePiece target, TranslatablePiece i18nPiece, String locationName, String zoneName, String boardName, String mapName)
	NonRectangular(String type, GamePiece inner)
	Obscurable(String type, GamePiece d)
	OldAndNewPieceProperties(Map<String,Object> oldPiece, GamePiece newPiece)
	PieceImage(GamePiece piece)	Deprecated, for removal: This API element is subject to removal in a future version.
	Pivot(String type, GamePiece inner)
	PlaceMarker(String type, GamePiece inner)
	PlaySound(String type, GamePiece piece)
	PropertySheet(String type, GamePiece p)
	Replace(String type, GamePiece inner)
	ReportState(String type, GamePiece inner)
	RestrictCommands(String type, GamePiece inner)
	Restricted(String type, GamePiece p)
	ReturnToDeck(String type, GamePiece inner)
	SendToLocation(String type, GamePiece inner)
	SetGlobalProperty(String type, GamePiece p)
	SetPieceProperty(String type, GamePiece p)
	SimplePieceEditor(GamePiece p)
	Stack(GamePiece p)	Creates a Stack to contain a specific stackable piece.
	SubMenu(String type, GamePiece inner)
	TableInfo(String type, GamePiece p)
	TranslatableMessage(String type, GamePiece p)
	Translate(String type, GamePiece inner)
	TriggerAction(String type, GamePiece inner)
	UsePrototype(String type, GamePiece inner)

Constructor parameters in VASSAL.counters with type arguments of type GamePiece

Modifier	Constructor	Description
	PieceIterator(Iterator<? extends GamePiece> i)
	PieceIterator(Iterator<? extends GamePiece> i, PieceFilter f)

Uses of GamePiece in VASSAL.i18n

Subinterfaces of GamePiece in VASSAL.i18n

Modifier and Type	Interface	Description
interface	TranslatablePiece	Decorators that contain localizable elements must implement this interface

Fields in VASSAL.i18n declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece	TranslatableMarker.markerDefinition
protected GamePiece	PieceI18nData.piece

Constructors in VASSAL.i18n with parameters of type GamePiece

Modifier	Constructor	Description
	ComponentI18nData(Configurable c, GamePiece piece)	Special build for PrototypeDefinition and PieceSlot
	PieceI18nData(GamePiece piece)

Uses of GamePiece in VASSAL.script

Methods in VASSAL.script with parameters of type GamePiece

Modifier and Type	Method	Description
Decorator	BshCommandEncoder.createDecorator(String type, GamePiece inner)

Uses of GamePiece in VASSAL.script.expression

Methods in VASSAL.script.expression with parameters of type GamePiece

Modifier and Type	Method	Description
boolean	BeanShellExpression.BshFilter.accept(GamePiece piece)	Deprecated.
boolean	BeanShellExpression.BshFilter.accept(GamePiece piece, Auditable owner, String fieldKey)
boolean	BeanShellExpression.BshFilter.accept(GamePiece piece, Auditable owner, AuditTrail audit)

Uses of GamePiece in VASSAL.script.proxy

Methods in VASSAL.script.proxy with parameters of type GamePiece

Modifier and Type	Method	Description
protected void	GamePiece.setVassalGamePiece(GamePiece g)

Constructors in VASSAL.script.proxy with parameters of type GamePiece

Modifier	Constructor	Description
	GamePiece(GamePiece g)

Uses of GamePiece in VASSAL.tools.imageop

Methods in VASSAL.tools.imageop that return GamePiece

Modifier and Type	Method	Description
GamePiece	GamePieceOp.getPiece()
GamePiece	GamePieceOpImpl.getPiece()	Returns the source GamePiece.

Methods in VASSAL.tools.imageop with parameters of type GamePiece

Modifier and Type	Method	Description
static GamePieceOp	Op.piece(GamePiece gp)

Constructors in VASSAL.tools.imageop with parameters of type GamePiece

Modifier	Constructor	Description
	GamePieceOpImpl(GamePiece gp)	Constructs an ImageOp which will produce an image from the given GamePiece.

Uses of GamePiece in VASSAL.tools.imports.adc2

Methods in VASSAL.tools.imports.adc2 that return GamePiece

Modifier and Type	Method	Description
protected GamePiece	ADC2Module.Piece.getBasicPiece()
protected GamePiece	ADC2Module.Piece.getGamePiece()