Uses of Interface
VASSAL.counters.GamePiece
Package
Description
Provides classes for building Java instances automatically from XML
files.
Contains classes that may be added to a
GameModule
.Contains classes that may be added to a
Map
.Contains classes that can be added to a
Widget
.Provides classes that implement the "Command" design pattern.
Provides classes for building "Edit Property" dialogs, and for editing
GameModule
's and ModuleExtension
's.Provides classes that define game pieces.
-
Uses of GamePiece in VASSAL.build
Modifier and TypeMethodDescriptionGameModule.createPiece(String type)
Central location to create any type of GamePiece from within VASSALGameModule.createPiece(String type, GamePiece inner)
Central location to create any type of GamePiece Trait (Decorator) from within VASSALGpIdChecker.createUpdatedPiece(GamePiece oldPiece)
Locate the SlotElement that matches oldPiece and return a new GamePiece created from that Slot.Modifier and TypeMethodDescriptionprotected void
GpIdChecker.checkTrait(GamePiece gp)
Check for PlaceMarker traits in a GamePiece and add them to the cross-referenceprotected void
GpIdChecker.checkTrait(GamePiece gp, PrototypeDefinition prototype, GamePiece definition)
protected void
Copy as much state information as possible from the old piece to the new pieceGameModule.createPiece(String type, GamePiece inner)
Central location to create any type of GamePiece Trait (Decorator) from within VASSALGpIdChecker.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 -
Uses of GamePiece in VASSAL.build.module
Modifier and TypeFieldDescriptionprotected GamePiece
Inventory.Counter.piece
protected GamePiece
Inventory.Counter.source
Modifier and TypeMethodDescriptionprotected GamePiece
BasicCommandEncoder.createBasic(String type)
Create aGamePiece
instance that is not a Decorator ("Trait").BasicCommandEncoder.BasicPieceFactory.createBasicPiece(String type)
BasicCommandEncoder.createPiece(String type)
Creates a GamePiece instance from the given type information.Map.findAnyPiece(Point pt, PieceFinder finder)
Use the providedPieceFinder
instance to locate any piece at the given location, regardless of whether it is visible or not.Map.findPiece(Point pt, PieceFinder finder)
Use the providedPieceFinder
instance to locate a visible piece at the given locationMap.getAllPieces()
Inventory.Counter.getPiece()
PrototypeDefinition.getPiece()
protected GamePiece
PrototypeDefinition.getPiece(PropertySource props)
For the case when the piece definition is a Message Format, expand the definition using the given propertiesGameState.getPieceForId(String id)
Map.getPieces()
Inventory.getSelectedCounter()
Modifier and TypeMethodDescriptionGameState.getAllPieces()
GameRefresher.getCurrentGameRefresherPieces()
GameState.getPieces()
Deprecated, for removal: This API element is subject to removal in a future version.Modifier and TypeMethodDescriptionboolean
void
Add aGamePiece
to the current game.void
Adds a GamePiece to this map's list of pieces.Map.boundingBoxOf(GamePiece p)
BasicCommandEncoder.createDecorator(String type, GamePiece inner)
BasicCommandEncoder.DecoratorFactory.createDecorator(String type, GamePiece inner)
protected int
Inventory.getTotalValue(GamePiece p)
int
Returns the index of a piece.Place a piece at the destination point.Map.placeOrMerge(GamePiece p, Point pt)
Move a piece to the destination 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 traitsvoid
Map.removePiece(GamePiece p)
Removes a piece from the mapvoid
Map.reposition(GamePiece s, int pos)
Deprecated, for removal: This API element is subject to removal in a future version.Map.selectionBoundsOf(GamePiece p)
void
void
void
Map.Merger.visitDefault(GamePiece piece)
-
Uses of GamePiece in VASSAL.build.module.map
Modifier and TypeFieldDescriptionprotected GamePiece
KeyBufferer.bandSelectPiece
protected GamePiece
PieceMover.dragging
protected GamePiece
HighlightLastMoved.lastMoved
protected GamePiece
SetupStack.StackConfigurer.myPiece
protected GamePiece
SetupStack.View.myPiece
Modifier and TypeFieldDescriptionCounterDetailViewer.displayablePieces
CounterDetailViewer.Visitor.pieces
MovementReporter.MoveSummary.pieces
protected Comparator<GamePiece>
PieceMover.pieceSorter
Modifier and TypeMethodDescriptionCompoundPieceCollection.getAllPieces()
PieceCollection.getAllPieces()
Return all pieces in the collection, regardless of visibilitySimplePieceCollection.getAllPieces()
CompoundPieceCollection.getPieces()
protected GamePiece[]
CompoundPieceCollection.getPieces(boolean includeDisabled)
PieceCollection.getPieces()
Return all currently-visible pieces in the collection as a read-only arraySimplePieceCollection.getPieces()
Modifier and TypeMethodDescriptionCounterDetailViewer.getDisplayablePieces()
Build an ArrayList of pieces to be displayed in order from bottom up, based on selection criteria setup in config.GlobalMap.CounterViewer.getDisplayablePieces()
CounterDetailViewer.Visitor.getPieces()
Modifier and TypeMethodDescriptionboolean
boolean
protected boolean
void
Adds a piece to the overall collection, by adding it to the simple collection for the layer it belongs in.void
Adds a piecevoid
DrawPile.addToContents(GamePiece p)
protected void
SelectionHighlighter.boundingBox(GamePiece p)
boolean
Used when moving a piece on top of another piece to determine whether they can be merged together (e.g.boolean
Return true if the two pieces can be merged into a single stackboolean
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
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)
StackMetrics.createStack(GamePiece p)
StackMetrics.createStack(GamePiece p, boolean force)
void
protected void
StackMetrics.drawUnexpanded(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
protected Rectangle
protected PieceCollection
CompoundPieceCollection.getCollectionForPiece(GamePiece p)
Given a game piece, returns the simple piece collection for the layer that it belongs inint
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).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.LayeredPieceCollection.Collection.getLayerNameForPiece(GamePiece p)
int
int
Returns the index of a piece.int
Returns the index of a piece.protected boolean
MovementReporter.HiddenMoveSummary.isInvisible(GamePiece piece)
Handles marking pieces as "moved" or "not moved", based on Global Options settings.Place a GamePiece on top of another GamePiece Create/remove stacks as necessary, even if stacking is disabled for this instanceprotected 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 layervoid
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 layervoid
SimplePieceCollection.moveToFront(GamePiece p)
StackMetrics.placeOrMerge(GamePiece fixed, GamePiece moving)
Merge the two pieces if stacking is enabled.StackMetrics.relativePosition(Stack parent, GamePiece c)
void
void
Removes the piecevoid
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 Commandsprotected Command
PieceMover.setOldLocations(GamePiece p)
Populates the "OldLocations" properties (e.g.CounterDetailViewer.Visitor.visitDefault(GamePiece p)
KeyBufferer.KBDeckVisitor.visitDefault(GamePiece p)
Handles non-stacked units, including Does Not Stack units.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.PieceRecenterer.visitDefault(GamePiece p)
ImplementsDeckVisitor
.Modifier and TypeMethodDescriptionprotected 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.UsePieceMover.applyKeyAfterMove(List, KeyStroke)
to return Commandsprotected void
CounterDetailViewer.drawGraphics(Graphics g, Point pt, JComponent comp, List<GamePiece> pieces)
protected void
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
Set the bounds field large enough to accommodate the given set of pieces -
Uses of GamePiece in VASSAL.build.module.properties
-
Uses of GamePiece in VASSAL.build.widget
Modifier and TypeFieldDescriptionprotected GamePiece
PieceSlot.c
protected GamePiece
PieceSlot.expanded
Modifier and TypeMethodDescriptionprotected GamePiece
PieceSlot.getExpandedPiece()
Return defined GamePiece with prototypes fully expanded.PieceSlot.getPiece()
Return defined GamePiece with prototypes unexpanded.Modifier and TypeMethodDescriptionvoid
void
PieceSlot.updateGpId(GamePiece piece)
Allocate new gpids in the given GamePiece -
Uses of GamePiece in VASSAL.command
Modifier and TypeMethodDescriptionprotected PieceVisitorDispatcher
MovePiece.createMergeFinder(Map map, GamePiece p, Point pt)
Creates a newPieceVisitorDispatcher
that will create aCommand
object to merge the target piece with any applicable pieces at the target location -
Uses of GamePiece in VASSAL.configure
Modifier and TypeMethodDescriptionboolean
boolean
protected void
FormattedExpressionConfigurer.storePiece(GamePiece p)
ModifierConstructorDescriptionBeanShellExpressionConfigurer(String key, String name, String val, GamePiece piece)
Create a labeled BeanShellConfigurer with an initial value and target pieceBeanShellExpressionConfigurer(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 pieceFormattedExpressionConfigurer(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)
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
Modifier and TypeInterfaceDescriptioninterface
If class implementing GamePiece also implements the EditablePiece interface, then it can be manipulated from the Editor's Configuration Tree via thePieceDefiner
dialog.Modifier and TypeClassDescriptionclass
A Trait (akaDecorator
that acts like a button on a GamePiece, such that clicking on a particular area of the piece invokes a key commandclass
class
Basic class for representing a physical component of the game.class
Conditional Marker A marker with a variable value depending on conditions.class
This trait adds a command that creates a duplicate of the selected Gamepiececlass
Trait that sends a Key Command to other pieces, selected with various filters.class
A collection of pieces that behaves like a deck, i.e.: Doesn't move.class
The abstract class describing a generic 'Trait' of a full GamePiece.class
This trait adds a command that creates a duplicate of the selected Gamepiececlass
Implements a trait to allow a piece to be deselected from the KeyBuffer in response to a Key Command.class
Trait that contains a property accessible via getProperty() and updatable dynamically via key commandsclass
The "Layer" trait.class
Embellishment has been extensively re-written for Vassal 3.2 changing both the behavior and the visual look of the configurer.class
Displays a movement trail indicating where a piece has been movedclass
A Decorator that rotates a GamePiece to an arbitrary angleclass
Adds a menu entry that fires a specified key event to the module window.class
class
Decorator that filters events to prevent a GamePiece from being selected and/or moved.class
Displays a text label, with content specified by the user at runtime.class
A generic Decorator that retains in its state the value of a property.class
This trait adds a command that creates a duplicate of the selected Gamepiececlass
A GamePiece with this trait will automatically be marked whenever it is moved.class
A trait for assigning an arbitrary shape to aGamePiece
class
class
Provides commands to pivot a Game Piece around a given pointclass
This Decorator defines a key command to places another counter on top of this one.class
A trait that plays a sound clipclass
A Decorator class that endows a GamePiece with a dialog.class
GamePiece trait that replaces a GamePiece with another oneclass
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 Restrict the availability of Key Commands, depending on a Property Match String.class
A GamePiece with the Restricted trait can only be manipulated by the player playing a specific sideclass
GamePiece trait that returns a piece to aDrawPile
class
This trait adds a command that sends a piece to another location.class
class
A Stack is a collection of pieces in the same location that can often be moved with a single drag-and-drop.class
A trait that groups menu items of other traits into a sub-menuclass
A Decorator class that endows a GamePiece with an editable spreadsheet (i.e.class
A trait to expose a translated string as a readable/displayable property.class
Give a piece a command that moves it a fixed amount in a particular direction, optionally tracking the current rotation of the piece.class
Macro Execute a series of Keystrokes against this same piece - Triggered by own KeyCommand or list of keystrokes - Match against an optional Property Filterclass
This trait is a placeholder for a pre-defined series of traits specified in aPrototypeDefinition
object.Modifier and TypeFieldDescriptionprotected GamePiece[]
Stack.contents
protected GamePiece
Obscurable.obscuredToMeView
protected GamePiece
Obscurable.obscuredToOthersView
protected GamePiece
TriggerAction.outer
protected GamePiece
Decorator.piece
Modifier and TypeFieldDescriptionPieceDefiner.availableList
protected static DefaultListModel<GamePiece>
PieceDefiner.availableModel
protected DefaultListModel<GamePiece>
PieceDefiner.inUseModel
Deck.nextDraw
protected ListCellRenderer<? super GamePiece>
PieceDefiner.r
PieceIterator.VISIBLE
Modifier and TypeMethodDescriptionstatic <T extends GamePiece>
PieceIteratorPieceIterator.visible(Enumeration<T> e)
Deprecated.static <T extends GamePiece>
PieceIteratorModifier and TypeMethodDescriptionStack.bottomPiece()
Stack.bottomPiece(String playerId)
PieceCloner.clonePiece(GamePiece piece)
Create a new instance that is a clone of the given piece.PlaceMarker.createBaseMarker()
The marker, with prototypes unexpandedPlaceMarker.createMarker()
The marker, with prototypes fully expandedReplace.createMarker()
protected GamePiece
Translate.findTarget(KeyStroke stroke)
GlobalCommandTarget.getCurPiece()
static GamePiece
Decorator.getDecorator(GamePiece p, Class<?> type)
UsePrototype.getExpandedInner()
Build a new GamePiece instance based on the traits in the referencedPrototypeDefinition
.Decorator.getInner()
static GamePiece
Decorator.getInnermost(GamePiece p)
static GamePiece
Decorator.getOutermost(GamePiece p)
PieceDefiner.getPiece()
Stack.getPieceAbove(GamePiece p)
Finds the piece "above" the one providedStack.getPieceAt(int index)
Stack.getPieceBeneath(GamePiece p)
Finds the piece "underneath" the one providedKeyCommand.getTarget()
PieceIterator.nextPiece()
protected GamePiece
PieceDefiner.removeDecorator(int index)
Remove the Decorator at a given position in the listReturn the argument GamePiece (or one of its children if a Stack) found at the given point on the given MapStack.topPiece()
CAUTION: returns the top VISIBLE piece in the stack, or null if none is visible.Modifier and TypeMethodDescriptionDragBuffer.asList()
KeyBuffer.asList()
Returns a list of all selected pieces.Stack.asList()
A list of the pieces in the stack.Deck.getOrderedPieces()
Return a list if pieces in the Deck in Dealable order.KeyBuffer.getPieces()
Deprecated.UseKeyBuffer.getPiecesIterator()
instead.Stack.getPieces()
Deprecated, for removal: This API element is subject to removal in a future version.useStack.asList()
Stack.getPiecesInReverseOrder()
Deprecated, for removal: This API element is subject to removal in a future version.Stack.getPiecesInVisibleOrder()
Deprecated, for removal: This API element is subject to removal in a future version.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.KeyBuffer.getPiecesIterator()
Returns an iterator for all selected pieces.Stack.getPiecesIterator()
Stack.getPiecesReverseIterator()
Modifier and TypeMethodDescriptionboolean
boolean
boolean
boolean
void
void
Adding a piece to theKeyBuffer
"selects the piece" (and lets it know about in its SELECTED property)void
Adds a piece to the stack.void
static void
PieceDefiner.addDefinition(GamePiece definition)
Plugins can add additional GamePiece definitionsprotected static void
PieceDefiner.addElement(GamePiece piece)
void
Translate.MoveExecuter.addKeyEventTarget(GamePiece piece)
void
ColoredBorder.boundingBox(GamePiece p)
Highlighter.boundingBox(GamePiece p)
PieceCloner.clonePiece(GamePiece piece)
Create a new instance that is a clone of the given piece.int
boolean
boolean
Tells if a particular piece is selected (i.e.void
Handle a mouse click on the given GamePiece at the given location (where 0,0 is the center of the piece).void
void
boolean
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 Layerstatic 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 Layerstatic GamePiece
Decorator.getOutermost(GamePiece p)
Stack.getPieceAbove(GamePiece p)
Finds the piece "above" the one providedStack.getPieceBeneath(GamePiece p)
Finds the piece "underneath" the one providedTranslate.MoveExecuter.getUpdatedPosition(GamePiece target)
Return the updated position of a piece that has a move calculation recordedprotected void
ColoredBorder.highlightSelectionBounds(GamePiece p, Graphics g, int x, int y, Component obs, double zoom)
int
Finds the index of a piece in the stackvoid
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 positionprotected 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 stackprotected 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
protected Command
Translate.moveTarget(GamePiece target)
protected Point
SendToLocation.offsetDestination(int x, int y, GamePiece outer)
Deck.pieceAdded(GamePiece p)
Stack.pieceAdded(GamePiece p)
Perform some action on a GamePiece that has just been added to this StackDeck.pieceRemoved(GamePiece p)
Stack.pieceRemoved(GamePiece p)
Perform some action on a GamePiece that has just been removed this Stackstatic Command
Decorator.putOldProperties(GamePiece p)
* Set the Oldxxxx properties related to movement (e.g.void
Deprecated, for removal: This API element is subject to removal in a future version.void
void
Deselect the specified piece -- removes it from theKeyBuffer
void
Return the argument GamePiece (or one of its children if a Stack) found at the given point on the given Mapprotected 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 onevoid
GlobalCommandTarget.setCurPiece(GamePiece curPiece)
void
void
void
static void
Decorator.setOldProperties(GamePiece p)
Deprecated, for removal: This API element is subject to removal in a future version.void
GlobalCommand.Visitor.visitDefault(GamePiece p)
PieceFinder.Movable.visitDefault(GamePiece piece)
PieceFinder.StackOnly.visitDefault(GamePiece piece)
PieceVisitor.visitDefault(GamePiece p)
GamePieces that are not handled by one of the type-specific methods (e.g.Modifier and TypeMethodDescriptionprotected Command
Deck.setContents(Collection<GamePiece> c)
Set the contents of this Deck to a Collection of GamePiecesprotected Command
Deck.setContents(Iterator<GamePiece> it)
Deprecated, for removal: This API element is subject to removal in a future version.UseDeck.setContents(Collection)
instead.void
DragBuffer.sort(Comparator<GamePiece> comp)
void
KeyBuffer.sort(Comparator<GamePiece> comp)
Sorts the selected pieces based on a particular ComparatorModifierConstructorDescriptionActionButton(String type, GamePiece inner)
AreaOfEffect(String type, GamePiece inner)
CalculatedProperty(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)
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)
FreeRotator(String type, GamePiece inner)
GlobalHotKey(String type, GamePiece inner)
Immobilized(String type, GamePiece p)
Immobilized(GamePiece p, String type)
Deprecated.UseImmobilized(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)
MenuSeparator(String type, GamePiece inner)
MovementMarkable(String type, GamePiece p)
NonRectangular(String type, GamePiece inner)
Obscurable(String type, GamePiece d)
PieceImage(GamePiece piece)
Deprecated.PlaceMarker(String type, GamePiece inner)
PropertySheet(String type, GamePiece p)
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)
Creates a Stack to contain a specific stackable piece.TranslatableMessage(String type, GamePiece p)
TriggerAction(String type, GamePiece inner)
UsePrototype(String type, GamePiece inner)
ModifierConstructorDescriptionPieceIterator(Iterator<? extends GamePiece> i)
PieceIterator(Iterator<? extends GamePiece> i, PieceFilter f)
-
Uses of GamePiece in VASSAL.i18n
Modifier and TypeInterfaceDescriptioninterface
Decorators that contain localizable elements must implement this interfaceModifier and TypeFieldDescriptionprotected GamePiece
TranslatableMarker.markerDefinition
protected GamePiece
PieceI18nData.piece
ModifierConstructorDescriptionComponentI18nData(Configurable c, GamePiece piece)
Special build for PrototypeDefinition and PieceSlotPieceI18nData(GamePiece piece)
-
Uses of GamePiece in VASSAL.script
Modifier and TypeMethodDescriptionBshCommandEncoder.createDecorator(String type, GamePiece inner)
-
Uses of GamePiece in VASSAL.script.proxy
-
Uses of GamePiece in VASSAL.tools.imageop
Modifier and TypeMethodDescriptionGamePieceOp.getPiece()
GamePieceOpImpl.getPiece()
Returns the sourceGamePiece
.ModifierConstructorDescriptionGamePieceOpImpl(GamePiece gp)
Constructs anImageOp
which will produce an image from the givenGamePiece
. -
Uses of GamePiece in VASSAL.tools.imports.adc2
Modifier and TypeMethodDescriptionprotected GamePiece
ADC2Module.Piece.getBasicPiece()
protected GamePiece
ADC2Module.Piece.getGamePiece()
GameState.getAllPieces()
instead.