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.map	Contains classes that may be added to a Map.
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.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()
List<GamePiece>	GameRefresher.getCurrentGameRefresherPieces()
Enumeration<GamePiece>	GameState.getPieces()	Deprecated, for removal: This API element is subject to removal in a future version. Use GameState.getAllPieces() instead.

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

Modifier and Type	Method	Description
boolean	Inventory.Selector.accept(GamePiece piece)
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)
int	Map.indexOf(GamePiece s)	Returns the index of a 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	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
void	Map.removePiece(GamePiece p)	Removes a piece from the map
void	Map.reposition(GamePiece s, int pos)	Deprecated, for removal: This API element is subject to removal in a future version. use PieceCollection.moveToFront(VASSAL.counters.GamePiece)
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

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

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)
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.
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.
protected void	MapShader.checkPiece(Area area, GamePiece piece)
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
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)	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 void	PieceMover.setOldLocation(GamePiece p)	Deprecated, for removal: This API element is subject to removal in a future version. PieceMover.setOldLocations(GamePiece) to return generated Commands
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 void	PieceMover.applyKeyAfterMove(List<GamePiece> pieces, Command comm, KeyStroke key)	Deprecated, for removal: This API element is subject to removal in a future version. Use PieceMover.applyKeyAfterMove(List, KeyStroke) to return Commands
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)	Set the bounds field large enough to accommodate the given set of pieces

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

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

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

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(GamePiece piece)
boolean	PropertyExpression.accept(GamePiece source, GamePiece piece)
protected void	FormattedExpressionConfigurer.storePiece(GamePiece p)

Constructors in VASSAL.configure with parameters of type GamePiece

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
FormattedExpressionConfigurer(String key, String name, String s, GamePiece p)
FormattedExpressionConfigurer(String s, GamePiece p)
FormattedStringArrayConfigurer(String key, String name, GamePiece target)
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	BasicPiece	Basic class for representing a physical component of the game.
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	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	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	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	Decorator that filters events to prevent a GamePiece from being selected and/or moved.
class	Labeler	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	MenuSeparator	This trait adds a command that creates a duplicate of the selected Gamepiece
class	MovementMarkable	A GamePiece with this trait will automatically be marked whenever it is moved.
class	NonRectangular	A trait for assigning an arbitrary shape to a GamePiece
class	Obscurable
class	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 top of this one.
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	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	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	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	A Decorator class that endows a GamePiece with an editable spreadsheet (i.e.
class	Translate	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	This trait is a placeholder for a pre-defined series of traits specified in a PrototypeDefinition object.

Fields in VASSAL.counters declared as GamePiece

Modifier and Type	Field	Description
protected GamePiece[]	Stack.contents
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 DefaultListModel<GamePiece>	PieceDefiner.inUseModel
protected List<GamePiece>	Deck.nextDraw
protected ListCellRenderer<? super GamePiece>	PieceDefiner.r
static 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.
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	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	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)
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	KeyCommand.getTarget()
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.
Enumeration<GamePiece>	KeyBuffer.getPieces()	Deprecated. 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()
Enumeration<GamePiece>	Stack.getPiecesInReverseOrder()	Deprecated, for removal: This API element is subject to removal in a future version. Use Stack.getPiecesInVisibleOrderIterator()
Enumeration<GamePiece>	Stack.getPiecesInVisibleOrder()	Deprecated, for removal: This API element is subject to removal in a future version. Use Stack.getPiecesInVisibleOrderIterator()
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()

Methods in VASSAL.counters with parameters of type GamePiece

Modifier and Type	Method	Description
boolean	BooleanAndPieceFilter.accept(GamePiece piece)
boolean	BooleanOrPieceFilter.accept(GamePiece piece)
Object	DeckVisitorDispatcher.accept(GamePiece piece)
boolean	PieceFilter.accept(GamePiece piece)
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)
static void	PieceDefiner.addDefinition(GamePiece definition)	Plugins can add additional GamePiece definitions
protected static void	PieceDefiner.addElement(GamePiece piece)
void	Translate.MoveExecuter.addKeyEventTarget(GamePiece piece)
void	BoundsTracker.addPiece(GamePiece p)
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.
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.
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 GamePiece	Decorator.getDecorator(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
Point	Translate.MoveExecuter.getUpdatedPosition(GamePiece target)	Return the updated position of a piece that has a move calculation recorded
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	Stack.insertPieceAt(GamePiece p, int index)	Insert a piece at a particular point in the stack
protected void	Replace.matchTraits(GamePiece base, GamePiece marker)
boolean	Deck.mayContain(GamePiece piece)	Does the specified GamePiece meet the rules to be contained in this Deck.
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)
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)
void	Decorator.setInner(GamePiece p)
void	FreeRotator.setInner(GamePiece p)
void	UsePrototype.setInner(GamePiece p)
static void	Decorator.setOldProperties(GamePiece p)	Deprecated, for removal: This API element is subject to removal in a future version.
void	PieceDefiner.setPiece(GamePiece piece)
Object	GlobalCommand.Visitor.visitDefault(GamePiece p)
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 Command	Deck.setContents(Collection<GamePiece> c)	Set the contents of this Deck to a Collection of GamePieces
protected Command	Deck.setContents(Iterator<GamePiece> it)	Deprecated, for removal: This API element is subject to removal in a future version. Use Deck.setContents(Collection) instead.
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

Constructor	Description
ActionButton(String type, GamePiece inner)
AreaOfEffect(String type, GamePiece inner)
CalculatedProperty(String type, GamePiece inner)
Clone(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. 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, NamedKeyStroke key, GamePiece target)
KeyCommand(String name, NamedKeyStroke key, GamePiece target, boolean enabled)
KeyCommand(String name, NamedKeyStroke key, GamePiece target, TranslatablePiece i18nPiece)
KeyCommandSubMenu(String name, GamePiece target, TranslatablePiece i18nPiece)
Labeler(String s, GamePiece d)
Marker(String type, GamePiece p)
MenuSeparator(String type, GamePiece inner)
MovementMarkable(String type, GamePiece p)
NonRectangular(String type, GamePiece inner)
Obscurable(String type, GamePiece d)
PieceImage(GamePiece piece)	Deprecated.
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)
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)
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

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

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

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

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