All Classes and Interfaces
Class
Description
Abstract superclass for any action where an entity is attacking another
entity.
This is a framework for boardview overlays that can show a list of data,
conditions etc.
This is the Base Dialog for a dialog with buttons in MegaMek.
A modal dialog for presenting options as buttons.
AbstractClient that handles basic client features.
Very simple skeleton for the command line parser.
Exception thrown in case of error
Generic bidirectional connection between client and server
Instances of descendant classes are sent as a result of changes of the Connection state or packet
arrival.
This is the base class for dialogs in MegaMek.
AbstractDirectory is a class that is used to define a directory.
This is a base implementation for
EntityAction.This is a base class to derive all types of Game (TW, AS, BF, SBF...) from.
We need a way to access the action map for a JComboBox editor, so that we can
have it fire an action when wenter is pressed.
This class ensures that every Help dialog in MegaMek has an identical
look-and-feel.
An AbstractIcon is an abstract class that ensures standardized and isolated image code for icons
across the suite.
An AbstractIconChooser is an abstract panel that is used to select an
AbstractIcon from the
various potential icons located within the specified AbstractDirectory.
Creates a dialog that allows players to select a directory from a directory tree and choose an
AbstractIcon from the AbstractIcons in that directory.
AbstractIconChooserTree is an extension of JTree that provides additional AbstractIcon specific
functionality to simplify initialization.
A specialized JList to display a list of AbstractIcons for the AbstractIconChooserDialog,
e.g.
This renders the AbstractIcon for the current Cell of the rendered list
This is a base class for Triggers that should only ever react once, regardless of how often its
prerequisites are satisfied.
Parent class for options settings
Abstract base class for Singletons representing Options' static information
such as displayable name, description etc.
This is the default Panel.
This class provides a skeletal implementation of pathfinder algorithm in a
given directed graph.
Factory for retrieving neighbouring edges.
Represents a function for retrieving destination node of an edge.
Represents a function that relaxes an edge.
Represents a function that allows removing unwanted objects from a
collection.
The stop condition that is processed after every successful relaxation.
A timeout stop condition.
This is the base class for all the "displays" which take control during the local player's turn.
This is a basic implementation of PlayerTurn to extend other turn types from.
This is the default Scrollable Panel, implementing Scrollable and designed to be used within a
ScrollPane, preferably AbstractScrollPane.
This is the default ScrollPane.
This is a base class for simple BoardPostProcessors where each hex can be processed independently
from other hexes.
This is a base class for the very similar ASFBay and SmallCraftBay.
This is the default SplitPane.
This is the default TabbedPane.
Base functionality for chassis and model records for RAT generator.
This is a heavily reworked version of the original MekSelectorDialog which
brings up a list of units for the player to select to add to their forces.
A specialized renderer for the mek table (formats the unit price).
A specialized renderer for the mek table (formats the unit tonnage).
This is the Base Dialog for a dialog with buttons where the Ok button
requires data validation
in MegaMek.
Contains common functionality for wreck sprites (currently isometric and regular)
Represents an action and the state of the board after the action is performed.
Contains information necessary to carry out a "blood stalker" action
This Trigger reacts when the count of active units is equal to the given count.
N.B.
Add a waypoint to a unit
This is the dialog for advanced unit filtering, mostly for the unit selector.
This is the dialog for advanced map filtering
Taharqa's attempt at creating an Aerospace entity
Applies damage to an Aero entity.
This set of classes is intended for use for pathfinding by aerodyne units on
ground maps with an atmosphere
Usage anywhere else may result in "unpredictable" behavior
This class removes all off-board paths, but keeps track of the shortest of
all the paths removed
This class is intended to be used by the bot for generating possible paths for
aerospace units on a low-altitude atmospheric map.
Class which keeps set of all areas required to represent ASF unit in
MekDisplay.ArmorPanel class.
Helper class that contains functionality relating mostly to aero unit paths.
AeroSpaceFighter subclass of Aero that encapsulates Fighter functionality
This class generates move paths suitable for use by an aerospace unit
operating on a space map, with 'advanced flight' turned off.
Creates a TRO template model for aerospace and conventional fighters.
Command to change the aggression level of the bot.
Ram attack by an airborne LAM in airmek mode.
This class represents a hex area that includes all hexes of the given board.
This command votes to allow another player to assume the elevated Game Master
role
This command allows a player to allow another player to switch teams.
This class represents an AlphaStrike Element which is a single unit such as a Mek with
AlphaStrike values such as S, M, L damage and a single Armor and Structure value.
This class contains static helper methods for AlphaStrike
This utility converts all units that can be converted and for which filter()
returns true to AlphaStrike elements and outputs the stats to the clipboard.
This is my attempt to get weapon bays treated as normal weapons rather than the current hack in
place
Set of flags that can be used to determine how the ammo is used and its
special properties
Shows a table of all units matching the chosen faction/unit type/era
parameters and
general criteria for a formation along with data relevant to the formation
constraints.
This Trigger implements a logic AND for all its subtriggers, i.e.
Class containing functionality that helps out with area effect weapons.
Dumb data structure intended to hold results from the calculateDamageFalloff
method.
Dumb data structure intended to hold characteristics associated with various
types of
NUCLEAR WEAPONS (thanks Ghandi).
Generic Argument class, can be extended for different argument types for server commands
Very cumbersome class that handles set of polygonal areas and labels for
PicMap component to represent single mek unit in MekDisplay
ArtilleryAttackAction Holds the data needed for an artillery attack in
flight.
Command to ignore a target unit for the bot.
ArtilleryCommandAndControl class represents the artillery command and control for the bot.
This class handles the creation of firing plans for indirect-fire artillery
and other weapons that get used during the targeting phase.
ArtilleryTracker - one held by every entity, it holds a list of the artillery
weapons an entity
controls, and the mods they get to hit certain hexes.
Small collector...
This panel shows advanced search filters for AlphaStrike values.
This class holds the AlphaStrike information for a firing arc of any element that uses arcs
such as a WarShip (WS)..
This class represents the (graphical) card of an AlphaStrike element as available on the MUL.
This interface is implemented by classes that can be displayed on an AlphaStrike card
ASCard.This is a JComponent that displays only an AlphaStrike unit card.
This class prints a collection of one or more Alpha Strike cards.
Static AlphaStrike Conversion class; contains all information for conversion
except for some weapon specifics
handled in WeaponType/AmmoType/MiscType.
Represents a single AlphaStrike damage value that may be minimal damage (0*).
Represents an AlphaStrike damage value combination of between 1 and 4 damage values which
typically correspond to S/M/L/E ranges.
This Jackson deserializer reads an AlphaStrikeElement from an MMU file.
This Jackson serializer writes AlphaStrikeElements to YAML output.
Represents a Transport Bay (TM p.239) for carrying Fighters/LAMs aboard large spacecraft or other units.
This is an Alpha Strike game object that holds all game information.
This class acts as a super class for heat tracking AlphaStrike card classes (for Meks and Fighters) as
these use a different layout from the other cards including the added heat bar.
This class provides AlphaStrike conversion utilities for converting all sorts
of locations
of TW units to the damage conversion location index.
This command exists to print entity information to the chat window, it's primarily intended for
visually impaired users.
This class encapsulates a block of AlphaStrike or Battleforce or SBF special abilities.
This interface is implemented by classes that represent anything that holds AlphaStrike Special
Unit Abilities.
This non-modal dialog shows stats of one or more AlphaStrike elements in the form of a table.
This class is used to create a short text summary of an Alpha Strike element
(or MekSummary) for export.
This class holds the AlphaStrike information for a turret (TUR) special ability.
Represents the AlphaStrike Element Types (ASC, page 91)
Describes a set of methods a class can use to represent an attack from some weapon.
Handles availability rating values and calculations for RAT generator.
Background drawer is a class which keeps reference to a single Image and
draws it according specified rules.
This is a form of an Image that is based on a base64-encoded form, e.g.
A very "basic" path ranker
Simple data structure that holds a separate firing and physical damage
number.
This class represents a squad or point of battle armor equipped infantry,
sometimes referred to as "Elementals".
Represents a volume of space set aside for carrying Battle Armor squads aboard large spacecraft
and mobile structures
Represents a set of handles on an OmniMek used by Battle Armor units
equipped with Boarding Claws to attach themselves for transport.
Class which keeps set of all areas required to represent Battle Armor unit in
MekDisplay.ArmorPanel class.
Creates a TRO template model for BattleArmor.
This trigger reacts when only units of a single team remain alive and on
board (this trigger
disregards undeployed units, offboard units, TeleMissiles, GunEmplacements
and MekWarriors!).
This class represents a battlefield control (units of only one team left alive) victory
Note that this currently does not exclude gun emplacements or spawns (MekWarriors, Missiles) from
the test.
This enum contains AlphaStrike, BattleForce and (some - WIP) Strategic BattleForce Special Unit Abilities
(SUAs) and some utility methods for them.
This interface is implemented by classes that have knowledge on which BattleForce Special Abilities
like SRCH, IT75, FLK2/2/0/0 or CK12D4 they need to display for themselves and how to format them.
A BattleArmor uses its vibroclaws
Represents a volume of space set aside for carrying cargo of some sort
aboard large spacecraft and mobile structures
Construction data used by transport bays for meks, vees, and aerospace units.
Data for various transport bay types.
This is my attempt to get weapon bays treated as normal weapons rather than the current hack in
place
Command to change the behavior of the bot.
BLkFile.java
This class loads BattleArmor BLK files.
BLkFile.java
Created on April 6, 2002, 2:06 AM
Class that holds data relating to transport bays
and functionality to parse .blk file transport bay entries
BLkFile.java
Created on April 6, 2002, 2:06 AM
This class loads Infantry BLK files.
This class loads ProtoMek BLK files.
Command to set a player as a dishonored enemy of the bot.
This class scans the boards directory and allows the selection of a random
board based on given size criteria.
This class handles the tracking of "clusters" of movable areas for various
movement types,
either with or without destruction awareness.
A data structure representing a set of coordinates to which an entity can
move.
Movement types that are relevant for "destruction-aware pathfinding"
Have a close relationship but are not exactly one to one with entity movement
modes.
Type-safe, immutable, dimensions class for handling board sizes.
This class is intended to be used to find a (potentially long) legal path
given a movement type from a particular hex to the specified board edge
Note: This class is largely obsolete now, only used for its static methods
Specialized field for the BoardEditor that supports MouseWheel changes.
This class is a
BoardViewTooltipProvider that is tailored
to the Board Editor and lists detailed terrain info about the hovered hex.Instances of this class are sent as a result of Board change
A FileFilter for MegaMek Board files.
Classes which implement this interface provide methods that deal with the
events that are generated when the Board is changed.
This adapter class provides default implementations for the methods described
by the
BoardListener interface.Represents a location (i.e.
a quick class for the new map dialogue box
This interface is implemented by classes that perform some action on a Board, such as making terrain changes.
Scans all boards and applies automated tags to them.
This class provides a utility to read in all the boards and check their validity.
Displays the board; lets the user scroll around and select points on it.
Instances of this class are sent as a result of changes in BoardView
This class is WIP, commiting just to have an artifact.
Classes which implement this interface provide methods that deal with the
events that are generated when the BoardView is changed.
This adapter class provides default implementations for the methods described
by the
BoardViewListener interface.This class represents the specialized JPanel that paints the contents of the BoardView.
The BoardViewsContainer manages the JPanel that contains the BoardView(s) of a ClientGUI.
This is a base class for SpriteHandlers that create and remove sprites in an attached BoardView.
This interface is implemented by classes that can be added to a BoardView to provide the tooltip contents
for the BoardView.
A dialog to determine bomb payload.
Argument for a boolean type.
This class represents one or more of the edge of any given board.
The Bot Commands Panel contains a small set of buttons which allow the player to change the configuration of any bot they have
control over during game play.
A dialog box to configure (Princess) bot properties.
A dialog for entering one or more entity IDs that are to be used as strategic targets by Princess.
This contains useful classes and functions for geometric questions
the bot algorithm might have
This is a convex area on the board made up of 6 lines lying along one of the
3 primary directions of a hex map
The combination of a coordinate and a facing
This describes a line in one of the 6 directions in board space
---copied from Coords---
Coords stores x and y values.
The help command lists the other commands when run without arguments.
The GameDatasetLogger class is used to log game data to a file in the log directory
with TSV format.
Command to change the bravery setting of the princess.
The attacker grapples the target.
Represents a basic carryable object with no additional other properties
The attacker brushes the target off.
This interface represents any physical object that can find itself on the
battlefield, including units of any sort (Entity, AlphaStrikeElement, BF
Unit, SBF Formation), but also objective markers, carryable objects,
noncombatants, buildings.
This class represents a single, possibly multi-hex building on the board.
buildingBlock is based on a file format I used in an online game.
This class represents a single, targetable hex of a building.
Building template, for placing on the map during map generation.
An extension of the MovePath class that stores information about terrain that
needs
to be destroyed in order to move along the specified route.
Comparator implementation useful in comparing two bulldozer move paths by
how many MP it'll take to accomplish that path, including time wasted
leveling any obstacles
A
JButton that will react
to ESC key presses when in a focused window.Base class for battle value calculators for all units.
This is a VictoryCondition that will match when a given percentage of all enemy BV is
no longer alive.
This is a VictoryCondition that will match when friendly BV over enemy BV is at least a given
ratio in percent.
A Lobby Mek Table sorter that sorts by BV.
This is a base interface with default helper methods for bv-checking VictoryConditions
A Lobby Mek Table sorter that sorts by C3 network association (and by ID after that).
A transient class used to lazy-load "calculated" information from an entity
This represents a report for any typical MegaMek suite calculation such as BV, cost or AS conversion.
Some static methods for called shots
CamoChooser is an implementation of AbstractIconChooser that is used to select a Camouflage
from the Camouflage Directory.
This dialog allows players to select the camouflage pattern (or colour) used by their units.
StandardForceIconChooserTree is an implementation of AbstractIconChooserTree that initializes the
tree using the Camouflage Directory, with the additional and external category of Colour
Camouflage added before any of the Camouflage Directory categories.
Camouflage is an implementation of AbstractIcon that contains and displays a
Camouflage, which
may either be a base Camouflage from the Camouflage directory or a Colour
camouflage, which is
based on the specified PlayerColour and then parsed as an AWT Color.
An
Action for
canceling a dialog (closing without action) using
setVisible(false).Class which keeps set of all areas required to represent Capital Fighter unit
in MekDisplay.ArmorPanel class.
Creates a TRO template model for advanced aerospace units (JumpShips,
warships, space stations)
Represents a volume of space set aside for carrying general cargo aboard large spacecraft and
mobile structures.
This is a temporary record for parsed info about a Carryable object (which do not have a position field)
Command to set the caution level of the bot.
Weaponhandler for the Centurion Weapon System weapon,
which is found in Jihad Conspiracies Interstellar Players 2, pg 127.
The Server Command "/changeOwner" that will switch an entity's owner to another player.
The Server Command "/changeOwner" that will switch an entity's owner to another player.
Represents one unit charging another.
The ChassisRecord tracks all available variants and determines how much total
weight
is to be distributed among the various models.
Interface for chat commands for the bot.
A command that exist purely for the accessibility UI so that commands can be made as the default rather than chat.
Represents the commands that the princess can execute.
ChatterBox keeps track of a player list and a (chat) message buffer.
A graphical chatterbox within the boardview.
Override of the basic
JComboBox that adds the capacity to checkpoint its current value.A (somewhat primitive) dialog that asks a question and lets the player select
from the available choices.
This class represents a hex area that is a filled "circle" around a center (all hexes up to a given maximum distance).
Represents the space on an standard Mek (i.e.
Represents the space on a vehicle used by Battle Armor squads equipped with
Magnetic Clamps to attach themselves for transport.
Added per IO Pg 53 - Tech Manual shows this is an IS weapon only
But IO seems to have made this a Clan weapon as well
Added per IO Pg 53 - Tech Manual shows this is an IS weapon only
But IO seems to have made this a Clan weapon as well.
Commented out in WeaponType.
Command to clear all waypoints from the unit behavior tracker.
Command to clear all ignored targets from the bot.
Command to clear all waypoints from this bot.
This is a specialized label that acts as a replacement for a button.
This class is instantiated for each client and for each bot running on that
client.
Dialog for executing a client command.
A MegaMek Dialog box.
This annotation is used to mark IGame and subclass methods that are intended for use by the Client only
(in other words, not by the Server/GameManager).
A ServerCommand that can only be used by Game Masters,
This abstract class implements many features that are common to all Game Master commands,
like the isGM check for users, it also uses the Argument class for building the command arguments
and to abstract the parsing of the arguments, limit assertion and error handling, and for building
a more dynamic "help" feature.
Commented out in WeaponType.
An
Action for
closing a dialog using setVisible(false).The attacker makes a club attack on the target.
Construction Factor Warning Logic.
Represents structure CF warnings for entities during deployment
and movement phase that will collapse if the entity lands-on
or is deployed on that structure.
Some utility methods for Collections.
This interface is for classes that represent combat units with battlefield roles (Sniper, Juggernaut,
Dogfighter...).
Class used in processing KeyEvents in
MegamekController.A commander node gives the rank to assign the force's commander, an optional title, and the
position within the force structure (typically in the first unit/subforce for a field officer).
This is MegaMek's Help -> About dialog
The menu bar that is used across MM, i.e.
The Client Settings Dialog offering GUI options concerning tooltips, map
display, keybinds etc.
Determines tech level dates based on tech progression of components.
The Compute class is designed to provide static methods for 'Meks and other
entities moving, firing, etc.
Similar to the Compute class, this class contains various static methods for
common computations related to ECM.
This is a JPanel that displays an AlphaStrike unit card and elements to configure the display of
the card and allow copying to clipboard.
This class wraps the MekView / MekViewPanel and gives it a toolbar to choose font, open the MUL
and copy the contents.
Stores and provides access to the configuration of the MegaMek library.
A simple yes/no confirmation dialog.
The Connect to game (as Bot or Player) dialog
Instances of this class are sent when Connection established
Connections factory.
Thread that runs and checks to see if there's any incoming packets from a connection.
Classes that wish to deal with
ConnectionEvents can extend this class and override
only the methods which they are interested in.Coords stores x and y values.
Argument for an Integer type.
Argument for an Integer type.
A dialog to display the cost calculation for a given entity.
This class counts elements
A type of game turn that allows only one specific entity to counterattack a break grapple by
the original attacker
Validates the coverage of a unit in the battlefield.
Program that will scan the data/images directory for images and take all of
the images in a subdirectory and store them in a single image atlas.
Health status, skills, and miscellanea for an Entity crew.
Description of crew.
This class parses the Crew from a YAML (scenario) file.
Represents a volume of space set aside for carrying a mobile structure or spacecraft's crew
Contains data used by crew to determine how many distinct crew members to track for name, damage,
and skills, and which crew normally execute which roles.
Represents a set of cube coordinates in a hex grid.
A dialog that a player can use to customize his mek before battle.
Controls for customizing crew in the chat lounge.
The DamageType enumeration is used for the damageEntity function.
This component draws a dashed horizontal line, similarly to a JSeparator.
Implementation of the AbstractConnection that uses the DataInputStream and
DataOutputStream to send/receive data.
Interface for a data verification object.
This class is for debugging Entity with respect to the internal state of
equipment.
This is the default Scrollable Panel implementation, designed to be used as a basic
implementation of AbstractScrollablePanel for inline scrollable panels that can then be used
within a scrollpane.
The Defaults node is at the beginning of a ruleset file and provides the default values for
that faction.
Acknowledges another players victory command.
This interface is implemented by those units (by InGameObjects) that can be deployed either offboard or on a board.
This dialog allows selecting an elevation (or altitude) during deployment.
This enumeration lists all the possible ActionCommands that can be
carried out during the deployment phase.
This enum gives the meaning of an elevation or altitude that a unit can be deployed to.
This enumeration lists all of the possible ActionCommands that can be
carried out during the deploy minefield phase.
Handles the generation of ground-based move paths that contain information
relating to the destruction of terrain necessary to accomplish that path.
A JButton that has a minimum width which scales with the GUI scale.
This class represents a collection of files present within a directory
hierarchy, categorized
according to their directories.
Instances of this class are sent when Connection closed
Disengagement action for offboard artillery
Generic set of PicMap areas do represent various units in MekDisplay class
This interface represents an event listener that can be "distracted" to ignore any event
notifications.
This class implements the Distractable interface.
Represents a Docking Collar (Docking Hardpoint, TO: AUE p.116) with which a
JumpShip,
WarShip, Space Station or Mobile Structure can carry one DropShip.
A command that exist purely for the accessibility UI so that commands can be made as the default rather than chat.
This class represents "victory" events that are a draw that can be added programmatically or from MM scenarios to check for a draw
result.
Implements internal bays for dropships used by primitive jumpships.
This is a Calculation Report that can be used when the report that comes with a
calculation isn't going to be used.
This class contains a collection of
ECMInfo instances that all
effect a particular location.A class that keeps track of information related to an ECM field.
Compares two ECMInfo to determine which should take precedence, assuming that the goal is to find the strongest
ECCM field.
Compares two ECMInfo to determine which should take precedence, assuming that the goal is to find the strongest
ECM field.
This class describes a vehicle crew that has abandoned its vehicle and now
functions as a rifle
foot platoon of equal size.
Support vehicle ejection seats.
This is a data record for a possible deployment elevation together with a DeploymentElevationType that signals if the elevation is, e.g.,
on the ground, on a bridge or submerged.
This is for simulating the vertically moving walls in the Solaris 7
colloseum.
This HexArea has no coords at all.
The Server Command "/end" that will finish a game immediately declaring forced victory for a player or their team.
Implements a victory condition that checks if all enemy commanders have been killed.
Tracks enemy units and calculates threat scores based on their positions and capabilities.
This class represents an engine, such as those driving 'Meks.
Entity is a master class for basically anything on the board except terrain.
This interface is implemented by all actions that game units - not restricted to Entity! - can
perform, such as attacks, charges or spotting.
An ordered List-like collection of EntityActions with a cached description of each action,
created as the action is added.
A modal dialog for choosing one or more Entities.
A type of game turn that allows only certain types of units to move.
Tracks fluff details for entities.
Handles the rotated and damaged and preview images for a unit.
The EntityImagePanel displays the Entity's Image using the provided camouflage.
This class provides static methods to save a list of
Entitys to,
and load a list of Entitys from a file.This exception is thrown if a mek or other cannot be properly loaded from a
file due to IO errors, file format errors, or whatever.
This enum represents the various Entity Movement Types
This interface represents Entity Movement Types
A dialog showing the unit readout for a given unit.
This exception is thrown if a mek or other cannot be properly saved from a
file due to IO errors, file format errors, missing fields, or whatever.
Implementing classes perform a test to determine if an
Entity
meets the selection criteria.EntityState describes a hypothetical situation an entity could be in when firing
Performs verification of the validity of different types of
Entity subclasses.The EntityViewPane displays the entity summary, TRO and AS card panels within a TabbedPane.
Class containing static functions that perform visibility computations
related to an entity
without the need to be a part of the Entity class itself.
weight class limits and names
This class handles logic for displaying various kinds of damage and
destruction decals
Argument for an Enum type.
This class builds the Equipment Panel for use in MegaMek and MekHQ
Represents a set of flags that can be used to represent the type and
special properties of the equipment.
Interface for entity flags, used by
EquipmentBitSet.
Class EquipmentMode describes a Equipment's particular mode.
Represents any type of equipment mounted on a 'Mek, excluding systems and
actuators.
Constants that can be used as lookup keys for
EquipmentType.get(java.lang.String).Static fields in this class annotated with {code @EquipmentName} will be checked by the unit tests
to verify they are valid
EquipmentType lookup keys.This class represents an Era of the BT Universe such as the Civil War or Star
League eras.
This singleton class is a handler for the Eras of the BT Universe like the
Civil War or the
Succession Wars.
This class describes a group of escape pods and/or lifeboats that has launched from a larger craft
A dialog of which exits are connected for terrain.
Enumeration of all 6 possible facings.
Stores data about factions used for building RATs, including
parent factions, factions to salvage from, and percentages of
Clan/SL/Omni tech.
Proportions of Clan/SL/Omni tech are given for major commands in the various
sourcebooks such as the Field Manual series.
This sprite is used to paint the field of fire
for weapons.
Fighter squadrons are basically "containers" for a bunch of fighters.
This is a specialized version of EntityImage for FighterSquadrons that assembles its icon from the
icons of the fighters that make up the squadron.
FileCamouflage is an implementation of Camouflage that does not take camos from the parsed directories
of MegaMek but is constructed directly from a local image file, e.g.
The FileNameComboBoxModel class is a ComboBoxModel that uses the file name as the value.
This util will go through all available units and filter them according to
the filter() method and print out any units that match the filter.
The entity tries to find a club.
FireControl selects which weapons a unit wants to fire and at whom Pay
attention to the difference between "guess" and "get".
The possible fire control types.
This class is a data structure meant to hold Fire Control related
state, to keep the FireControl class relatively stateless.
The Server Command "/firefight" that will put one hex on fire.
The Server Command "/firestarter" that will put one hex on fire.
The Server Command "/firestorm" that starts a blazing inferno on the board.
This BoardViewSpriteHandler handles the sprites for the firing arcs (field of
fire) that can be shown for
individual weapons or bays.
This enumeration lists all of the possible ActionCommands that can be
carried out during the firing phase.
Represents intention to change a fire mode of a weapon.
FiringPlan is a series of
WeaponFireInfo objects describing a full attack turnThis data structure contains parameters that may be passed to the "determineBestFiringPlan()"
Used to track data for displaying "FiringSolution" data in the BoardView.
Represents a volume of space set aside for carrying crew or passengers in more luxury than standard quarters.
Helper class that contains common functionality for flamer-type weapons.
This class represents parachute flares deployed by illumination artillery
or mech mortars.
A Sprite for a flare, as the name indicates.
This builder class is used to assign fonts and font styles to JComponents in the Swing GUI using FlatLaf's typography system.
This Trigger reacts when the count of units that fled the battlefield is equal to the given count.
Command to set the bot to flee to a specific edge of the map.
The Flight Path Indicator Sprite paints a path in front of an aerospace movement path
and indicates the turn status and remaining velocity by showing the length of path
the flight must follow and when the unit can turn.
This class provides methods for retrieving fluff images, for use in MM, MML
and MHQ; also
for record sheets (where the fallback image "hud.png" is used).
This is a custom ComboBox that allows you to select a font from your available fonts, each
displayed in that font.
FontDisplay is a display wrapper around a Font, primarily to be used in ComboBoxes.
This singleton class reads in the available fonts when first called, including those in
SuiteConstants.FONT_DIRECTORY.A representation of a force or part of a force.
This interface represents all GameObjects that can be assigned to a force in MM.
BalancedConsolidateForces is a helper class that redistribute entities and forces
in a way to consolidate then into valid forces to build Formations out of them.
Describes the characteristics of a force.
A specialized renderer for the Mek Force tree.
Shows force display
Controls to set options for force generator.
Presents controls for selecting parameters of the force to generate and a
tree structure showing
the generated force.
A force node contains the rules for generating a force when the
ForceDescriptor matches the
characteristics defined by the force node.
Manages a collection of Forces for a game.
Campaign Operations rules for force generation.
base class for limitations on formation type
A helper class for highlighting and darkening hexes.
This class represents a single, possibly multi-hex fuel tank on the board.
Fuel type affects costs of refueling (if tracking fuel) and possibly vehicle operating
range.
This interface is implemented by objects that represent a collection of reports representing the
course of a game.
The game class is the root of all data about the game in progress.
Instances of this class are sent when game board changed - added/removed
minefield and so on
Instances of this class are sent when the new board for game is set
A Client Feedback Request Event.
The GameDatasetLogger class is used to log game data to a file in the log directory
with TSV format.
Instances of this class are sent when the game finished
This class represents events that can be added programmatically or from MM scenarios to check
for game end.
Instances of this class are sent game entity is changed
Instances of descendant classes are sent as a result of Game changes related
to entities such as addind/removing/changing
Instances of this class are sent when entity is added to game
Instances of this class are sent when new Offboard entity is added to game
Instances of this class are sent when entity is removed
Instances of descendant classes are sent as a result of Game change
Classes which implement this interface provide methods that deal with the
events that are generated when the Game is changed.
This adapter class provides default implementations for the methods described
by the
GameListener interface.This is a helper class used by GameManagers (not Clients) to create packets to send to the Clients.
Instances of this class are sent when Client is asked for the Map
This command starts a vote to allow player to assume the elevated Game Master
role
A ServerCommand that can only be used by Game Masters,
This abstract class implements many features that are common to all Game Master commands,
like the isGM check for users, it also uses the Argument class for building the command arguments
and to abstract the parsing of the arguments, limit assertion and error handling, and for building
a more dynamic "help" feature.
Instances of this class are sent when new Action added to the game
Contains the options determining play in the current game.
Responsible for displaying the current game options and allowing the user to change them.
Instances of this class are sent when Game phase changes
Instances of this class are sent when some Player is changed
Instances of this class are sent when chat message received
Instances of this class are sent when some Player connected
Instances of this class are sent when some Player disconnected
Instances of descendant classes are sent as a result of Game changes related to Players
Instances of this class are sent when an strategic action is created in the game
Normally, reports are dealt with during report phases.
This class is a container for the various reports created by the server
during a game.
Instances of this class are sent when Game settings are changed
This Trigger reacts at the start of the first initiative phase, i.e.
Represents a single turn within a phase of the game, where a specific player has to declare
his/her action.
Instances of this class are sent when Game turn changes.
This enum lists the different BT game types; TW for Total Warfare (using Entity as unit class), AS
for Alpha Strike, BF for BattleForce and SBF for Strategic BattleForce
An event that is fired at the end of the victory phase, before the game state
is reset.
A helper class for setting line-wise GridBagLayouts
Do not use this if you need a Component to span two rows
In this context, sex relates to the character's capacity to incubate offspring.
Set of elements to represent general unit information in MekDisplay
This program will generate a list of all the units that use the default
(generic) icons.
This class allows for dynamic Geysers to be added to maps which will go off
every few turns.
GifWriter
Utility class to create a gif from a series of images of a game summary.
Thread that writes frames to a GIF file.
The attacker grapples the target.
Represents cargo that can be picked up from the ground.
A building with weapons fitted and, optionally, a turret.
Class which keeps set of all areas required to represent GunEmplacement unit
in MekDisplay.ArmorPanel class.
This class represents a half plane shape.
A hazardous liquid pool can be wind-blown, pushed by water flow, both, or neither.
Methods that implement the Hazardous Liquid Pool as described in TO:AR p.
This class is instantiated for the player.
Tracks activity of units on the map.
Represents a Transport Bay (TM p.239) for carrying heavy vehicles (not heavier than 100t) aboard large spacecraft
or other units.
The help command lists the other commands when run without arguments.
This is a basic help dialog that can display HTML pages and also reacts to hyperlink clicks.
Command to change the herding mentality of the bot.
Hex represents a single hex on the board.
This class represents an area composed of hexes.
This class represents the subtraction (difference) of two HexAreaShapes.
This class represents the intersection of two HexAreaShapes.
This class represents the addition (union) of two HexAreaShapes.
Provides utility methods and constants for drawing hex-related shapes
Internally all methods work as if the game hex was
- as wide as BoardView1.HEX_W (usually == 84)
- perfectly hex-shaped, i.e.
- as wide as BoardView1.HEX_W (usually == 84)
- perfectly hex-shaped, i.e.
This area is defined by the hex level (aka floor height) being in the range defined by the given level(s).
Argument for a Coords from HexNumber type.
This class provides a utility to read in a HexTileSet and test to make
sure all images are accessible
An ancestor class for all Sprites that can be enclosed within a single hex.
Matches each hex with an appropriate image.
This is a result from the hit chart.
The host game dialog shown when hosting a new game and when loading a game
This is a Calculation Report that builds its output as an HTML text which can be obtained
from toString() as a String or from toJComponent() inside a JEditorPane.
Methods shared by Aero and LandAirMek
This interface represents Armor States
Basic option.
Basic interface for options group.
Common interface for all entities capable of carrying bombs and making bomb
attacks, includig Aero,
LandAirMek, and VTOL.
An interface defining all the required properties of a carryable object.
Executes both
MekSetTest and GenerateGenericIconList for a
combined icon problems result.Represents a hex, not in the game but in an ideal coordinate system.
Used for Boardview overlays that don't move when the map is scrolled
(such as the chat window).
A Lobby Mek Table sorter that sorts by unit ID.
This interface represents Entity Removal Conditions
Common interface for games with different rule sets, such as Total Warfare,
BattleForce, or Alpha Strike.
Provides common interface for the server to interact with different types of
games.
Command to ignore all units from a target player.
Command to ignore a target unit for the bot.
Command to ignore all turrets in the game
This interface represents the Location Exposure Status
Class to encapsulate a map that maps old image paths to the subsequent
location in an image atlas.
Class to map a file path to a location within an image atlas file.
Class to encapsulate a list of image atlas records for the purposes of
serialization.
An ImageCache that keeps a Hashtable of mapped keys and values.
A FilenameFilter that produces image files (PNG, JPG/JPEG, GIF).
This program was designed to test the idea of turning an image into a board
file for MegaMek.
Generic utility methods for image data
ImageLoader that loads sub-regions from a larger atlas file, but is given file names that are mapped into an
atlas.
ImageLoader implementation that expects a path to an image file, and that file is loaded directly and the loaded
image is returned.
Interface that defines methods for an ImageLoader.
ImageLoader that loads sub-regions from a larger atlas file.
Classes implementing this interface are expected to be able to return a mek
with the getMek
method or throw an EntityLoadingException.
Extension of java.awt.image.AreaAveragingScaleFilter.
Argument for a special type that can be Increase, Decrease or Set an Integer value.
This class represents Conventional Infantry (with BattleArmor as a subclass).
Represents a volume of space set aside for carrying infantry platoons aboard large spacecraft
and mobile structures.
Represents a volume of space set aside for carrying troops and their equipment under battle
conditions.
This class is intended to help the bot calculate firing plans for infantry
units.
Set of areas for PicMap to represent infantry platoon in MekDisplay
Stats for beast mounted infantry units.
This set of classes is intended to be used by AI players to generate paths
for infantry units.
TODO
Any vehicular unit (including battle armor, ProtoMeks, Combat Vehicles and
BattleMeks) successfully struck by a shot from a MagPulse harpoon gun will
suffer electronic interference sufficient to cause a -1 roll modifier
for all Gunnery and Sensor Operations Skill Checks by its pilot for 10
seconds (1 Total Warfare combat turn), in addition to any physical damage the
weapon delivers.
TAG for conventional infantry.
Classes that implement this interface have the ability to load, carry, drop, and
unload Infantry units in the game.
The amount of space taken up by an infantry unit in a transport bay differs from the space
in an infantry compartment (used in APCs) due to quarters, equipment storage, and maintenance
equipment.
Creates a TRO template model for conventional infantry.
Specialized mount used for infantry units with primary and secondary weapons.
This class records and defines the effects of hits by Inferno rounds on units
and hexes.
This interface represents all objects that any type of BT Game (TW, Alpha Strike, BattleForce, SBF, ISAW)
should possibly keep in its list of playable "entities" or game units, such as Entity and AlphaStrikeElement
and at some point maybe BFUnits, SBFFormations or ACS Combat Teams, but also Objective Markers, carryable
objects or buildings.
A roll, or sequence of rolls, made by the player to determine initiative order.
Represents a volume of space set aside for carrying insulated cargo
Argument for an Integer type.
Class to handle internationalization (you will find online material on that looking for i18n)
It makes use of some short names to make it easier to use since it is used in many places
A text field for integer values that can specify a minimum and maximum value.
Custom exception for receipt of an Invalid Packet Command received over the network.
Interface of the settable option.
Public interface for the group of the options.
Represents GUI data to allow the user to set the option
Interface that represents the "static" (common to all instances) information
about the Options container
Commented out in WeaponType.
Commented out in WeaponType.
Commented out in WeaponType.
This serves both as the Fa-Shih's Light TAG and the Kage's IS Compact TAG, as the stats are the same.
Commented out in WeaponType.
Commented out in WeaponType.
Commented out in WeaponType.
Commented out in WeaponType.
Commented out in WeaponType.
Commented out in WeaponType.
TODO - These Long Toms jam on the roll of a two
Duplicate of IS BA RL, not available to mechs at this rack size
Commented out in Weapontype
Duplicate of IS BA RL, not available to mechs at this rack size
Commented out in Weapontype
Duplicate of IS BA RL, not available to mechs at this rack size
Commented out in Weapontype
Duplicate of IS BA RL, not available to mechs at this rack size
Commented out in Weapontype
No Ammo listed in Ammotype for this guy.
The Improved One-Shot Thunderbolt 10
The One-Shot Thunderbolt 10
The Improved One-Shot Thunderbolt 15
The One-Shot Thunderbolt 15
The Improved One-Shot Thunderbolt 20
The One-Shot Thunderbolt 20
The Improved One-Shot Thunderbolt 5
The One-Shot Thunderbolt 5
Determines whether a piece of technology (a part, construction option, or entire unit) meets
certain constraints such as intro year, tech base, or tech level.
Implemented by any class that is subject to tech advancement (entities, equipment, systems, etc.)
Convenience interface that allows classes to implement the ITechnology
interface by delegating
to a member that implements ITechnology.
This interface represents a categorizable file.
This interface represents a factory that can produce items from categorizable files.
JComboBoxPreference monitors the selected index of a JComboBox.
This panel is used when you want a JPanel that enables/disables all of its children when it is
enabled/disabled.
JDoubleNumberSpinnerPreference monitors the value of a JSpinner whose number
model is for a double.
JIntNumberSpinnerPreference monitors the value of a JSpinner whose number
model is for an int.
JListPreference monitors the selected indices of a
JList.Deprecated.
JSplitPanePreference monitors the location of the split divider on a
JSplitPane.
JTabbedPanePreference monitors the selected tab of a JTabbedPane.
JTablePreference monitors the latest sort column and sort order of a JTable.
JTextFieldPreference monitors the text value of a JTextField.
JTextFieldPreference monitors the selected state of a JToggleButton (which
JCheckbox extends).
The attacker kicks the target.
Class which keeps set of all areas required to
represent ASF unit in MekDisplay.ArmorPanel class.
JWindowPreference monitors the size (width and height), location, and
maximization state of a Window.
Filters the pixels in the image by making all pixels that are the designated
"key" color transparent.
An overlay for the Boardview that displays a selection of keybinds
for the current game situation
This class provides a static method to read in the defaultKeybinds.xml and
set all of the
KeyCommandbind's based on the specifications in
the XML file.This interface may be implemented by classes that receive keybind key presses, such as the
BoardView or PhaseDisplays to simplify registering those keybinds.
This enum is a collection of commands that can be bound to a particular key.
The attacker kicks the target.
Kicks a player off the server.
Implements a kill count victory condition.
This Trigger reacts when the count of units that were killed is in a given
range.
The style of unit label display (full, shortened, show the nickname, etc.)
Crew class for LAMs which tracks separate skills for 'Mek and Fighter modes,
and chooses the correct one based on the LAM's current movement mode.
This is a large support vehicle
Class which keeps set of all areas required to represent Tank unit in
MekDisplay.ArmorPanel class.
A Board Editor dialog asking the user for a desired level change for the board.
Represents a Transport Bay (TM p.239) for carrying light vehicles (not heavier than 50t) aboard large spacecraft
or other units.
This class represents a line of hexes through the given point in the given hex row direction.
Represents a volume of space set aside for carrying liquid cargo
Command to list all available commands.
This class represents a shape formed by a given list of one or more Coords.
Lists all the save games in the savegames directory
Represents a volume of space set aside for carrying livestock
Loads a saved game on the server
This class contains the methods that perform entity and force changes from
the pop-up menu and elsewhere.
Contains static methods that show common info/error messages for the lobby.
This key dispatcher catches Ctrl-C / Ctrl-V keypresses in the lobby to allow copy/pasting units
without being obstructed by focus.
The ActionListener for the lobby popup menu for both the MekTable and MekTrees.
This class provides static helper functions for the Lobby aka ChatLounge.
Saves the current game.
Saves the current game.
Thrown by Mek, if a location is too full for new equipment.
Path finder that specialises in finding paths that can enter a single hex
multiple times.
Comparator that sorts MovePaths based on lexicographical order of
triples:
Works only with aeros.
(hexes traveled; thrust used; 0 - (hexes flown in a straight line))
Works only with aeros.
Relaxer for aero movement.
Relaxer for longest path movement.
Comparator that sorts MovePaths based on, in order, the following criteria:
Minefield hazard (stepping on less mines is better)
Least MP used
Most distance moved
Comparator that sorts MovePaths based on lexicographical order of pairs:
( movement points used; -(hexes moved) )Allows the player to select the type of entity in the hexes used by the LOS
tool.
Keeps track of the cumulative effects of intervening terrain on LOS
This Dialog is used as a unit browser for MegaMek's main menu.
A (somewhat primitive) dialog that asks a question and lets the player select
from the available choices.
Maneuver types for Aeros
Display a small dialog with adjustable settings for the dimensions of the playing board
Context menu for the board.
A specialized JButton for the map preview panel of the Lobby.
MapSettings.java
A helper class that is used for storing and retrieving map setups in the
lobby.
This is the primary MegaMek class.
A Border that has an image for each corner as well as images for the line
in between each corner (an edge).
A subclass of JButton that supports specifying the look and feel of the
button via a SkinSpecification.
This class parses the options passed into to MegaMek from the command line.
This class implements a KeyEventDispatcher, which handles all generated
KeyEvents.
This is an interface for a parameter-less method without a return value.
This is a local MegaMek version of java.io.File and is designed to support
having files that could exist in two locations: the MM install location and
a userdata directory.
You know what Meks are, silly.
Represents a Transport Bay (TM p.239) for carrying Meks or LAMs aboard large spacecraft other units.
This class provides a utility to read in all the /data/mekfiles and print
that data out into a CSV format.
Instances of this class are sent as a result of changes in MekDisplay
Classes which implement this interface provide methods that deal with the
events that are generated when the MekDisplay is changed.
This adapter class provides default implementations for the methods described
by the
MekDisplayListener interface.Switches between the various type-specific parsers depending on suffix
A specialized renderer for the Mek Force tree.
The TransferHandler manages drag-and-drop for the C3 tree.
Very cumbersome class that handles set of polygonal areas and labels for PicMap component to
represent single mek unit in MekDisplay
Class to perform filtering on units.
This class allows to create a tree where the leaf nodes contain names
and quantities of pieces of equipment while the non-leaf nodes contain
boolean operations (AND and OR).
This class provides a utility to read in the current MekSet and test to make
sure all images are accessible
The MekSummary of a unit offers compiled information about the unit without having to load the file.
Cache of the Mek summary information.
An interface for the Comparators used for the lobby Mek table.
MekTileSet is a misleading name, as this matches any unit, not just Meks with the appropriate image.
A Comparator for the top level entries of the Mek Tree (forces and force-less entities).
Creates a TRO template model for BattleMeks, OmniMeks, and IndustrialMeks
of all leg configurations.
A utility class for retrieving unit information in a formatted string.
This class acts as a superclass to BipedMek and TripodMek to unify code that is shared between them, most of it arm-related as both have
two arms while QuadMeks have none.
Memory class to store data for state processing and decision-making.
A class that provides scrolling capabilities to a long menu dropdown or
popup menu.
Ask for the setting for a vibrabomb.
Interface for classes that can plan minefield deployments.
This class contains logic to evaluate the damage a unit could sustain from
moving a long a move path containing minefields
A dialog displayed to the player when they want to lay mines with their BA
unit.
Obviously, displays the map in scaled-down size.
Contains geometric paths for drawing the minimap unit symbols.
Shows reports, with an Okay JButton
Set of flags that can be used to determine special equipment properties
and behaviors.
Used to adjust availability to conform to a particular mission role.
MMButton is an extension of JButton that overrides the constructors for JButton, albeit with the
addition of the name of the button as the first value for all constructors, and adds two new
constructors to create standardized JButtons with all of the required information.
MMBuMMComboBox is an extension of JComboBox that overrides the constructors for JComboBox,
albeit with the addition of the name of the button as the first value for all constructors and
a nicer override of getSelectedItem so that it returns in the proper class.
A simple modal confirmation dialog showing a single question and YES
and NO buttons.
These are constants that hold across MegaMek.
Base class for all events
Utility class to handle logging functions as well as reporting exceptions to Sentry.
These are constants related to logging messages to for output.
This is a class with a single static instance that will take markdown flavored text and parse it
back out as HTML, using the commonmark-java library.
An event triggered after the MMOptions are changed.
Used by Compute to generate random numbers, usually dice rolls.
Subclass of the roll tracker for
MMRandom entropy sources.Subclass of the roll tracker for
Pool36Random "entropy" sourcesThis is the base class for MM dialogs that have a similar look to Story Arc dialogs.
A JToggleButton that shows a check mark and cross mark to make its
selection status clearer.
This class has methods for reading objects such as SBF Formations, Units and AlphaStrikeElements
from a MMU file which uses YAML formatting.
This class has static methods for writing information to a MMU file which uses YAML formatting
to hold information about SBF Formations, Units and AlphaStrikeElements.
Specific unit variants; analyzes equipment to determine suitability for
certain types of missions in addition to what is formally declared in the
data files.
Method for handling morale with Princess.
This describes equipment mounted on a Mek.
Helper methods for Mounted to clean up checks like "is this an Artemis IV".
This enumeration lists all of the possible ActionCommands that can be carried
out during the movement phase.
This class handles the sprites shown on an attached BoardView for the movement envelope (showing the hexes
where a currently selected unit can move to in the movement phase).
Sprite for displaying information about movement modifier that can be
achieved by provided MovePath.
Holds movement path for an entity.
Generic implementation of AbstractPathFinder when we restrict graph nodes to
(coordinates x facing) and edges to MovePaths.
Node defined by coordinates and unit facing.
Returns the final CoordsWithFacing for a given MovePath.
Filters edges that are illegal.
A MovePath comparator that compares number of steps.
This filter removes MovePaths that need more movement points than
specified in constructor invocation.
A MovePath comparator that compares movement points spent.
Filters MovePaths that are forcing PSR.
Functional Interface for
MovePathFinder.NextStepsAdjacencyMap.getAdjacent(MovePath)A single step in the entity's movement.
This class represents a setting used to calculate walk, run, jump or sprint
MP.
This class represents mtf files which are used to store Meks.
Class for reading in and parsing MUL XML files.
Argument for a List of Coords from HexNumber type.
A dialog that allows the user to select some count of ints within some range.
Princess-Bot fire control class used to calculate firing plans for units that
can shoot at multiple targets without incurring a penalty.
This tool goes through the name_changes.txt file and performs various tests:
- it finds all lines where the left and right side are equal (i.e.
A Lobby Mek Table sorter that sorts by unit name.
This interface is implemented by scripted event objects that show a story or informative messages in
a dialog.
A comparator that compares the inputs based on natural sort order.
Standard naval repair facilities for space stations (jumpships and warships can also carry a single facility).
This set of classes is intended to be used by AI players to generate paths
for infantry units.
Naval Gauss Weapon superclass
The Server Command "/nofires" removes all fires on the board.
A dialog for creating/editing a note that is attached to a hex via the
SpecialHexDisplay framework.Argument for a List of Coords from HexNumber type.
This "Trigger" is used to invert another Trigger.
When used on a method, this annotation denotes that the method may return a null value.
This interface represents Off-Board Directions
This class handles the display and logic for the off board targeting overlay.
An
Action for
getting an Okay/Done response from a button in a dialog
Assigns the Messages.Okay text to the button.This Trigger can be used to turn a given sub-trigger into a one-time-only trigger.
Nullable Argument for an Enum type.
Optional Argument for an Integer type.
Optional Argument for a Password String type.
Optional Argument for a String type.
An OptionGroupNode is an adapter that allows two or more alternative ValueNodes to be
used when one is expected, and provides information on how to make the selection.
Represents an orbital bombardment event.
Builder of an orbital bombardment event.
An Order is a
Orders is a collection of orders that are loaded into a game.
This Trigger implements a logic OR for all its subtriggers, i.e.
Application layer data packet used to exchange information between client and server.
Generic marshaller that [un]marshalls the
PacketInstances of this class are sent when packet received
Contains the options for partial repair properties
This class contains functionality that takes a given path
and generates a list of child paths that go up to walk/run/run+masc/sprint/sprint+masc MP usage.
This class contains logic that calculates and stores
a) possible paths that units in play can take, and
b) their possible locations
The possible path ranker types.
This class handles state information for Princess' path ranking algorithms, as the path ranker and its
subclasses are intended to be basically stateless.
Defines things that need to be updated each phase.
This enumeration lists all the possible ActionCommands that can be
carried out during the physical phase.
TODO: add more options, pushing, kick both for quad Meks, etc.
Generated by a first pass through the physical attack actions
PicMap is a lightweight component, which area is composed by the set of custom
elements added to PicMap Engine.
Represents an external or exposed support vehicle crew seat.
Set of elements to represent pilot information in MekDisplay
Contains the options determining abilities of the pilot
This class contains helper methods for Special Pilot Abilities.
This class will hold all the information on planetary conditions and a variety of helper functions
for those conditions
A dialog that allows for customization of planetary conditions
An overlay for the Boardview that displays a selection of Planetary Conditions
for the current game situation
This interface is meant to be implemented by IGame subclasses (game types) that use planetary conditions.
Represents a player in the game.
This class represents the player-agreed /victory through chat commands
Argument for an Integer type for player ID.
A Lobby Mek Table sorter that sorts for 1) Player 2) BV.
A dialog that can be used to adjust advanced player settings like initiative, minefields, and maybe other things in
the future like force abilities.
A Lobby Mek Table sorter that sorts by 1) player 2) tonnage.
A Lobby Mek Table sorter that sorts by 1) player 2) transported units 3) ID.
This interface is implemented by player turns (e.g.
A Lobby Mek Table sorter that sorts by 1) player 2) unit role.
PMAreasGroup allows to group handle PicMap elements as single entity.
Generic element of PicMap component
Abstract class which defines common functionality for all hot areas such as
event handling and dispatching.
Generic Hot area of PicMap component
This is a label that can stretch across multiple lines
Simple rectangle hot are for PicMap component.
Simple polygonal area for PicMap component.
Class for drawing a simple polygon, used to display the polgyon areas for
different locations on an Entity.
Set of useful function.
This display is used for when hidden units are taking pointblank shots.
This enumeration lists all of the possible ActionCommands that can be
carried out during the pointblank phase.
Portrait is an implementation of AbstractIcon that contains and displays a
Portrait from the
Portrait Directory.
PortraitChooser is an implementation of AbstractIconChooser that is used to select a Portrait
from the Portrait Directory.
PortraitChooserDialog is an implementation of AbstractIconChooserDialog that is used to select a
Portrait from the Portrait Directory.
PortraitChooserTree is an implementation of AbstractIconChooserTree that initializes the tree
using the Portrait Directory.
unit_potential_locations keeps track of all the potential coordinates and
facings a unit could reach It tries to keep all the calculations up to date,
and do most of the work when the opponent is moving
Represents the set of information needed to be part of the user preferences system for MegaMek.
Represents a group of
PreferenceElements that are part of the same
Class.PrephaseDisplay for revealing hidden units.
This enumeration lists all of the possible ActionCommands that can be
carried out during the Prephase.
Prephase turn currently used for revealing hidden units
Deric "Netzilla" Page (deric dot page at usa dot net)
This class is a builder for settings for a Princess bot (BehaviorSettings) and also supports parsing
such settings from a yaml MM scenario definition.
Command to set a priority target unit for the bot.
This class stores all the calculations of probabilities given the rule set
This class handles pathfinding for situations where the unit is prone and
wants to remain prone for whatever reason (no leg, getting up will result in
exposure to fire, etc)
ProtoMeks.
Represents a volume of space set aside for carrying ProtoMeks aboard large spacecraft and mobile
structures
Represents a section of a Mek torso where a protomek equipped with the
magnetic clamp system
can attach itself for transport.
Class which keeps set of all areas required to represent ProtoMek unit within the
MekDisplay.ArmorPanel class.
The attacking ProtoMek makes its combo physical attack action.
Creates a TRO template model for Protomeks.
The attacker punches the target.
The attacker pushes the target.
Very cumbersome class that handles set of polygonal areas and labels for
PicMap component to represent single mek unit in MekDisplay
Quad Mek that can convert into either tracked or wheeled vehicle mode.
QuickGameRunner This class is used to run a game without minimal preparation all it needs is a game file to load and it will populate the
bots in the game and run the game the predefined number of turns, or until the game ends or until it times out.
Class to store pertinent quirk information.
Contains the options determining Unit Quirks of a unit (but not weapon quirks).
This class loads the default quirks list from the mmconf/cannonUnitQuirks.xml
file.
Represents one unit charging another.
Parameters for the random army generator
A table model for displaying units
Save File Formatting:
callsign, weight
Callsign is a String that does not include a ','
Weight is an integer weight that is used during generation
Author's Note: This is for generating Biological Gender (strictly speaking, the term is Sex) only,
with the other-style generation being implemented for future gender identity use
Minefield deployment planner that randomly selects positions on the board.
The random names dialog allows the player to randomly assign names to pilots based on faction and gender.
This class sets up a random name generator that can then be used to generate
random pilot names.
This class sets up a random unit generator that can then be used to read in user-created input files of random
assignment tables
Keeps track of a RAT entry, stores the name of a unit in the RAT, and its change of appearing (weight).
Plain old data class used to represent nodes in a Random Assignment Table tree.
This class provides export for MM's RAT data to an excel-optimized CSV file
for exchanging data with the MUL team.
Generates a random assignment table (RAT) dynamically based on a variety of
criteria, including faction, era, unit type, weight class, equipment rating,
faction subcommand, vehicle movement mode, and mission role.
This class represents a line of hexes starting at the given point and extending in the given hex row direction.
This class keeps a list of recently opened board files and makes it available statically.
Bare data class to pass around and store configuration-influencing info
This class represents a rectangle shape.
Represents a volume of space set aside for carrying refrigerated cargo
Reinforced naval repair facility allows ship to expend thrust with docked unit.
Command to remove the last waypoint added from the unit's behavior tracker.
This class defines a single server report.
Resets the server
This class contains static methods to obtain the current code revision
hashCode of all three programs.
Encapsulate all information known about a requested roll.
Filters an image by rotating it.
This Trigger is satisfied at any point during its given game round.
Defines things that need to be updated each round.
A series of rounding methods that account for floating point precision issues.
This class represents a half plane shape.
This is the ruler for LOS stuff implemented in command line.
Container for all the rule nodes for a faction.
Base class of all nodes in the Force Generator faction ruleset files.
Saves the current game.
This interface is implemented by actions of units (mostly, formations) in SBF games.
This interface is implemented by SBF's action handlers, typically attack handlers.
This is a base class for SBF artillery attacks, indirect, against hexes,
units or fortifications or direct.
This is the game client for Strategic BattleForce games, as one would think.
Represents the Strategic Battleforce element types (IOps, page 328)
Represents a Strategic Battle Force Formation composed of one or more SBF Units.
This Jackson deserializer reads an SBFFormation from an MMU file.
This Jackson serializer writes an SBF Formation to YAML output.
This is a turn for a player action that uses a unit (formation).
This class gathers the full game report for an SBF game.
This is an SBF game's game object that holds all game information.
This class manages an SBF game on the server side.
This dialog is used to ask the player how many JUMP points are to be used for a planned movement.
Represents the movement modes used in Strategic Battle Force
Returns true if last processed move path had final position equal to
destination.
A MovePath comparator that compares movement points spent and distance to
destination.
This filter removes MovePaths that need more movement points than
specified in constructor invocation.
A MovePath comparator that compares movement points spent.
Relaxes edge by favouring MovePaths that end in a not prone stance.
This is a turn for a player action that does not use a unit (formation).
Work In Progress
This class represents a Strategic BattleForce Record Sheet.
This class represents a collection of Strategic BattleForce sheets.
Shows reports, with an Okay JButton
This interface is implemented by objects that regularly need to check the rules options
used in an SBF game.
This non-modal dialog shows stats of one or more SBF Formations in the form of a table.
A panel with a table of Strategic Battle Force stats for any SBF Formations that are added to it.
This is a subclass of AbstractPlayerTurn that is (for now) only used to have a clear SBF designated
turn so that SBF classes don't use AbstractPlayerTurn directly.
Represents an SBF Unit (Ground SBF Unit or Aerospace Flight) which contains between 1 and 6 AlphaStrike
elements and is the building block of SBF Formations.
This Jackson deserializer reads an SBF Unit (part of a formation) from an MMU
file.
This Jackson serializer writes an SBF Unit (part of a formation) to YAML output.
This class holds visibility information for an SBF game.
This enum represents the various states of visibility used in SBF games with the Recon rules,
IO BF p.195.
This class will produce
Image objects from files.A JPopupMenu that automatically scales with MegaMek's GUI Scaling value
obtained from
GUIPreferences.getGUIScale()This dialog lists all scenarios found in MM's scenario directory as well as
the corresponding user directory.
Allow a user to set types and colors for scenario players
This panel displays a single
Scenario object in a well-formatted manner for display in the ScenarioChooser.This is a JList renderer for
ScenarioInfoPanel.This class holds all scenario info loaded from a scenario (.mms) file.
Ask for the setting for a vibrabomb.
Used for aiming a searchlight at a target.
Represents a volume of space set aside for carrying second class passengers
Allows an observer to see all units
This enumeration lists all the possible ActionCommands that can be
carried out during the select arty auto hit phase.
This class will hold all the information about a particular active sensor,
including its rolls
Class that off-loads serialization related code from Server.java
This class contains computations carried out by the Server class.
This annotation is used to mark IGame and subclass methods that are intended for use by the Server
and GameManager only (in other words, not by the Client).
Command to set waypoints for a unit.
Implementation of MovePathFinder designed to find the shortest path between
two hexes or finding shortest paths from a single hex to all surrounding.
Relaxes edge based on the supplied comparator, with special
considerations for flying off the map (since this will likely always look
back to the comparator).
Returns true if last processed move path had final position equal to
destination.
A MovePath comparator that compares movement points spent and distance to
destination.
Compares MovePaths based on distance from final position to destination.
Relaxes edge by favouring MovePaths that end in a not prone stance.
Command to show the current behavior of the bot.
Command to show all dishonored enemies.
This command exists to print entity information to the chat
window, it's primarily intended for visually impaired users.
This command exists to print entity information to the chat window.
This command exists to print tile information to the chat window, it's primarily intended for
visually impaired users.
This command exists to print tile information to the chat window and is
primarily intended for
visually impaired users.
An enum for the various rules levels
Helper interface for classes that need to interact with the
SimulationManager.Allows a bot to see all units via /singleblind command.
BalancedConsolidateForces is a helper class that redistribute entities and forces
in a way to consolidate then into valid forces to build Formations out of them.
A command that displays unit or terrain information
given an entity ID, parameters and maximum distance
Panel with elements for viewing and adjusting different SkinSpecification instances.
A class that contains state information that specifies a skin.
Panel with elements for viewing and adjusting a specific SkinSpecification.
This class reads in an XML file that specifies different aspects of the
visual skin for MegaMek.
Skips the current player's turn, if possible.
A simple prompt.
Represents a Transport Bay (TM p.239) for carrying SmallCraft or Fighters/LAMs aboard large spacecraft or other units.
Creates a TRO template model for small craft and DropShips
Panel that allows splitting ammo between standard and inferno for light and
medium weapons
that have inferno variants.
Ammo for light and medium weapons used by small support vehicles.
Contains a sound Clip to allow for managing playback
Class that tracks whether this shot was fired using a weapon with special to-hit handling.
A type of game turn that allows only one specific entity to move.
This Trigger reacts at the end of the specified game round.
This Trigger reacts at the start of the specified game round.
Class which keeps set of all areas required to
represent ASF unit in MekDisplay.ArmorPanel class.
This set of classes is intended to be used by AI players to generate paths
for units behaving like spheroid DropShips in atmosphere.
The SpinnerCellEditor is a Cell Editor for a cell that is edited through the provided spinner
model.
A 1.4 file that provides utility methods for
creating form- or grid-style layouts with SpringLayout.
Everything in the main map view is either the board or it's a sprite
displayed on top of the board.
Class which keeps set of all areas required to represent Capital Fighter unit
in MekDisplay.ArmorPanel class.
Represents a standard support vehicle crew seat.
This is a specialized StreamTokenizer that uses a configuration that many of MM's text files share.
Denotes a method created purely for the purposes of wrapping a static method call in a non-static
method so that a mock can be created.
This is a parent class for the button display for each phase.
Comparator for comparing the priority of two commands, used to determine
button order.
Interface that defines what a command for a phase is.
Represents a (cramped) volume of space set aside for carrying a mobile structure or spacecraft's
crew
This class calculates and stores points of polygon shaped as straight arrow.
Argument for a String type.
This is a helper class to ease the process of drawing Strings in Java
Graphics2D.
Node while contains rules for generating subforces -- either lower eschelons or the actual
units if this is a bottom-level eschelon.
Annotation to put on public methods which wish to receive events.
These are constants that hold across the entire MegaMek Suite of MegaMek,
MegaMekLab, and MekHQ.
An event triggered after the SuiteOptions are changed.
Displays a summary info for a unit, using the same html formatting as use by the board view map tooltips.
Class which keeps set of all areas required to represent Tank unit in
MekDisplay.ArmorPanel class.
Represents a Transport Bay (TM p.239) for carrying superheavy vehicles (not heavier than 200t)
aboard large spacecraft or other units.
This is a support vehicle
Creates a TRO template model for support vehicles.
This is a support vehicle VTOL
This is an SBF move step that happens on the surface of a hex, i.e.
Manages the center of a swarm of friendly units.
Context class to control the units as a swarm.
This is a Calculation Report that builds its output as an assembly of JLabels in a JPanel.
The TableColumnManager can be used to manage TableColumns.
You know what tanks are, silly.
Class which keeps set of all areas required to represent Tank unit in
MekDisplay.ArmorPanel class.
Represents a trailer hitch that allows a wheeled or tracked vehicle to tow trailers.
A modal dialog for choosing one or more Targetable objects.
Command to target a ground hex for strategic building.
Targeting Phase Display.
This enumeration lists all of the possible ActionCommands that can be
carried out during the deploy minefield phase.
Keeps track of a target for a roll.
This class represents individual modifiers for a
TargetRoll.The Team class holds information about a team.
Argument for an Integer type.
Team Chat
Notes: check out - RATGenerator.java - ForceDescriptor.java for era-based search examples
A JPanel that holds a table giving an overview of the current relative
strength
of the teams of the game.
Handles the progression of technology through prototype, production, extinction and reintroduction
phases.
Contains some constants representing equipment/unit tech levels
Compares computed static tech level to what is in the unit file and reports
all units that have equipment that exceeds the declared tech level, followed
by a list of all the equipment that caused failures.
Represents one tele-controlled missile attack
Ask for the velocity setting for a teleoperated missile.
TeleMissile Tracker - holds a list of tele-missiles controled by this entity and
information on what particular weapon controls them
Configuration for FreeMarker templates
Represents a single type of terrain or condition in a hex.
This class represents a hex area that is based on the terrain of the hex itself or even terrain in some distance to the present hex.
Validation and construction data for advanced aerospace units (jump ships, warships, space stations)
Class for testing and validating instantiations for Conventional Fighters and
Aerospace Fighters.
An enumeration that keeps track of the legal manipulators for
BattleArmor.
Abstract parent class for testing and validating instantiations of
Entity subclasses.Class for testing and validating instantiations for Small Craft and Drop-ships.
Author: arlith
Additional construction data for chassis mods, used to determine whether they
are legal for particular units.
Additional construction data for engine types, used to determine which ones
are available for which vehicle types.
Support vehicle categories for construction purposes.
This is a Calculation Report that builds its output as a monospace-formatted pure text
String.
The prone attacker thrashes at the target.
Handles loading and manipulating images from both the mek tileset and the
terrain tileset.
a singleton class (I hate singletons) to act as a central point for things
requiring timer services in clients.
Provides static helper functions for creating entity and crew tooltips.
Contains details about which units and eschelon levels are available to this unit in given eras.
Contains the to-hit number and a short description of how it was reached
A Lobby Mek Table sorter that sorts by tonnage.
An XML adapter that handles converting an Object to an XML string and back.
When deploying units that are towing units, let's mark hexes that would break the tow linkage
with warning.
The Server Command "/traitor" that will switch an entity's owner to another player.
Generates drop-ships and jump ships to fulfill transport requirements for a unit.
Classes that implement this interface have the ability to load, carry, and
unload units in the game.
This interface is implemented by Triggers that enable events like messages, game end, defeat or victory.
A dialog displayed to the player when they have an opportunity to trigger an
Anti-Personell Pod on one of their units.
A type of game turn that allows only one specific entity to trigger their Anti-Personnel pods
against attacking infantry.
A dialog displayed to the player when they have an opportunity to trigger an
Anti-BA Pod on one of their units.
A type of game turn that allows only one specific entity to trigger their Anti-Battle Armor
pods against attacking infantry/BA.
This interface is implemented by pre-determined events that may happen over the course of a game, such as
story messages or board changes.
This interface is implemented by pre-determined events that may happen over the course of a game, such as
game end or victory that do not change the game status but only examine it.
The attacker kicks the target.
Very cumbersome class that handles set of polygonal areas and labels for
PicMap component to represent single mek unit in MekDisplay
Fills in a template to produce a unit summary in TRO format.
Weaponhandler for the Tight-Stream Electro-Magnetic Pulse (TSEMP) weapon,
which is found in FM:3145 pg 255.
Tight-Stream Electro-Magnetic Pulse (TSEMP) weapon.
Abstract class to serialize/deserialize objects to/from TSV format.
An overlay for the Boardview that displays info about the users turn, such as list of users Move or Attack commands
for the current game situation
This class takes a time limit, which is to be set in Basic Options and counts down to zero
When zero is reached, the ready() method of the given
AbstractPhaseDisplay is called
to end the users current turn.A handy utility class for collecting
Vectors of
TurnOrdered markers and then walking through them.Panel that allows the user to create a unit filter.
Manages the Game and processes player actions.
A Lobby Mek Table sorter that sorts by unit type.
Represents a UI Theme for Swing.
A panel for the content of a subsection of the dialog.
A JPanel that does not stretch horizontally beyond its preferred width.
A JPanel that does not stretch vertically beyond its preferred height.
A specialized panel for the header of a section.
A panel for a subsection of the dialog, e.g.
A JButton with a specialized tooltip display.
A MMComboBox with a specialized tooltip display.
A JLabel with a specialized tooltip display.
A JList with a specialized tooltip display.
A MMToggleButton with a specialized tooltip display.
A JPanel with a specialized tooltip display.
A JSlider with a specialized tooltip display.
A JTextField with a specialized tooltip display.
This is a specialized JPanel for use with a button bar at the bottom of a dialog for when it's possible that the
button bar has to wrap (is wider than the dialog and needs to use two or more rows for the buttons).
This panel shows the centered notice saying "Under Construction" with a warning sign above.
Represents a unit action.
serializer and deserializer for UnitAction to/from TSV format.
Argument for an Integer type.
Represents a volume of space set aside for carrying units of some sort
aboard large spacecraft and mobile structures
Displays the info for a mek.
A class that contains state information that specifies a skin for the
UnitDisplay.
Panel with elements for viewing and adjusting a specific
UnitDisplaySkinSpecification.
This dialog will allow the user to edit the damage and status characteristics
of a unit.
This is not a functional tool, just some template code to use when changing
unit files programmatically.
A simple class to specify a location and facing for a unit.
Provides a means to track unit names for collisions.
A type of game turn that allows only entities belonging to certain units to move.
This Trigger reacts when the count of units in a certain board area is in a given range.
Unit roles as defined by Alpha Strike Companion, used in formation building
rules in ASC and Campaign Operations
Represents the state of a unit.
serializer and deserializer for UnitState to/from TSV format.
Manages random assignment table generated by RATGenerator.
This class is a record of pair of a (InGameObject) unit and a (Targetable) target.
weight class limits and names
Concrete implementation of and entity action for unloading entities that are
stranded on immobile transports.
A type of game turn that indicates that one or more players should be given the opportunity
to unload entities that are stranded on immobile transports.
Generic node which contains a value, a proportional weight to be used in random selection,
and the number of times to be applied.
Creates a TRO template model for combat vehicles.
Command to do nothing because it is marked to be removed.
This is an extension of the
JTextField that includes the capacity for DataVerifier
objects to be added.This is used for versioning, and to track the current Version the suite is
running at.
Weapon handler for vehicular grenade launchers.
Ask for the setting for a vibrabomb.
Causes automatic victory at the end of the current turn.
Interface for classes judging whether a victory occurred or not.
This class manages the victory conditions of a game.
A Victory Result stores information about the results of checking one or more victory conditions.
This class represents victory events that can be added programmatically or from MM scenarios to check for victory of a team.
Enum of valid formatting styles, to use with MekView objects
HTML: contains HTML markup
Discord: Contains Discord markup and formatting
None: plain text
Class which keeps set of all areas required to represent VTOL unit in
MekDisplay.ArmorPanel class.
This panel shows the centered notice saying "Waiting for Server".
Class which keeps set of all areas required to
represent ASF unit in MekDisplay.ArmorPanel class.
A class representing a weapon.
Represents intention to fire a weapon at the target.
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by arcs with
ties arbitrated based on damage (high to low).
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by BV, needed
for BV calculation Only pass Mounteds into this that are weapons
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by a custom
ordering.
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by damage
with ties arbitrated based on heat (lower heat wins).
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by weapon
number.
Comparator for sorting Weapons (Mounteds that have WeaponTypes) by Range.
WeaponFireInfo is a wrapper around a WeaponAttackAction that includes
probability to hit and expected damage
A basic, simple attack handler.
This class loads the custom weapon orders lists from the
mmconf/customWeaponOrder.xml files.
This class contains the all the gizmos for firing the mek's weapons.
This class represents the weapon quirks of an individual weapon.
Generated by a first pass through the weapon attack list.
A type of mek or vehicle weapon.
Set of flags that can be used to determine how the weapon is used and its
special properties
note: many weapons can be identified by their ammo type
Cycle through hexes on a map and make any necessary adjustments based on weather
What will happen here:
- add light and heavy snow for snowfall
- add ice for snowfall, sleet, and ice storm
- add/take away(?) rapids and torrent for winds
- add mud, rapids, and torrent for rain (no that has to be done before play starts so it is in
server.applyBoardSettings()
- put out fires (DONE)
This class contains data and logic for temperature restrictions.
Constructs a table of values each with a double weight that makes them more or less likely to be
selected at random
Constructs a table of values each with an int weight that makes them more or less likely to be
selected at random
Lists all the players connected and some info about them.
This class has been downloaded from a third-party source:
Author: Rob Camick
Website: https://tips4java.wordpress.com/2008/11/06/wrap-layout/
FlowLayout subclass that fully supports wrapping of components.
XTableColumnModel extends the DefaultTableColumnModel .
ChangeTeamCommandinstead.