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)
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)
GamePiece	GameModule.createPiece(String type, GamePiece inner)
GamePiece	GpIdChecker.createUpdatedPiece(GamePiece oldPiece)	Locate the SlotElement that matches oldPiece and return a new GamePiece created from that Slot.
boolean	GpIdChecker.findUpdatedPiece(GamePiece oldPiece)

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

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.
Rectangle	Map.boundingBoxOf(GamePiece p)	Returns the boundingBox of a GamePiece accounting for the offset of a piece within its parent stack.
Decorator	BasicCommandEncoder.createDecorator(String type, GamePiece inner)	Creates a Decorator instance
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)	Returns the position of a GamePiece accounting for the offset within a parent stack, if any
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)	Returns the selection bounding box of a GamePiece accounting for the offset of a piece within a stack
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)

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)
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)
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)
protected boolean	LayeredPieceCollection.Collection.canPiecesMerge(GamePiece p1, GamePiece p2)
protected boolean	CompoundPieceCollection.canStackAndPieceMerge(Stack s, GamePiece p)
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)
int	CompoundPieceCollection.getLayerForPiece(GamePiece p)
int	DefaultPieceCollection.getLayerForPiece(GamePiece p)
int	LayeredPieceCollection.Collection.getLayerForPiece(GamePiece p)
String	CompoundPieceCollection.getLayerNameForPiece(GamePiece p)
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	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 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 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)
Object	CounterDetailViewer.Visitor.visitDefault(GamePiece p)
Object	KeyBufferer.KBDeckVisitor.visitDefault(GamePiece p)
Object	LayeredPieceCollection.Collection.visitDefault(GamePiece p)
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)
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)
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 gpid's 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)
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)
FormattedExpressionConfigurer(String key, String name, 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)
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 a GamePiece implements the EditablePiece interface, then it can be manipulated from the Configuration Tree via the PieceDefiner dialog.

Classes in VASSAL.counters that implement GamePiece

Modifier and Type	Class	Description
class	ActionButton	A trait that acts like a button on a GamePiece, such that clicking on a particular area of the piece invokes a keyboard command
class	AreaOfEffect
class	BasicPiece	Basic class for representing a physical component of the game Can be a counter, a card, or an overlay
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	Adds a menu item that applies a GlobalCommand to other pieces
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 GamePiece.
class	Delete	This trait adds a command that creates a duplicate of the selected Gamepiece
class	DynamicProperty	Trait that contains a property accessible via getProperty() and updateable 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 collection of GamePieces which can be moved as a single unit
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
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)
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)
GamePiece	Stack.getPieceAt(int index)
GamePiece	Stack.getPieceBeneath(GamePiece p)
GamePiece	KeyCommand.getTarget()
GamePiece	PieceIterator.nextPiece()
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()
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()
List<GamePiece>	Stack.asList()
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()
Iterator<GamePiece>	KeyBuffer.getPiecesIterator()
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)
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
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)
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)
GamePiece	Stack.getPieceBeneath(GamePiece p)
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)
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	Deck.insertPieceAt(GamePiece p, int index)
protected void	Stack.insertPieceAt(GamePiece p, int index)
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
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)
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)
void	Decorator.setInner(GamePiece p)	Set the inner GamePiece
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)

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