From 3571beba21e223974fd9af1696718db8762a3649 Mon Sep 17 00:00:00 2001 From: Scoppio Date: Fri, 31 Jan 2025 18:21:01 -0300 Subject: [PATCH 1/4] feat: turn all the F_ flags from MiscType, AmmoType and WeaponType into enum flags, and adds a bitset on Equipment --- .../src/megamek/client/ui/swing/MapMenu.java | 3 +- megamek/src/megamek/common/AmmoType.java | 45 +- megamek/src/megamek/common/AmmoTypeFlag.java | 71 +++ megamek/src/megamek/common/Entity.java | 17 +- .../src/megamek/common/EquipmentBitSet.java | 129 +++++ megamek/src/megamek/common/EquipmentType.java | 22 +- megamek/src/megamek/common/IndexedFlag.java | 39 ++ megamek/src/megamek/common/Mek.java | 5 +- megamek/src/megamek/common/MiscType.java | 463 +++++++++--------- megamek/src/megamek/common/MiscTypeFlag.java | 287 +++++++++++ megamek/src/megamek/common/WeaponType.java | 144 +++--- .../src/megamek/common/WeaponTypeFlag.java | 168 +++++++ .../common/pathfinder/CachedEntityState.java | 12 +- .../verifier/TestAdvancedAerospace.java | 3 +- .../common/verifier/TestSmallCraft.java | 3 +- .../common/verifier/TestSupportVehicle.java | 8 +- .../bayweapons/CapitalMDBayWeapon.java | 4 +- .../common/weapons/other/CLLaserAMS.java | 2 +- .../common/weapons/other/ISLaserAMS.java | 2 +- .../weapons/unofficial/ISLaserAMSTHB.java | 2 +- .../client/bot/princess/FireControlTest.java | 7 +- 21 files changed, 1062 insertions(+), 374 deletions(-) create mode 100644 megamek/src/megamek/common/AmmoTypeFlag.java create mode 100644 megamek/src/megamek/common/EquipmentBitSet.java create mode 100644 megamek/src/megamek/common/IndexedFlag.java create mode 100644 megamek/src/megamek/common/MiscTypeFlag.java create mode 100644 megamek/src/megamek/common/WeaponTypeFlag.java diff --git a/megamek/src/megamek/client/ui/swing/MapMenu.java b/megamek/src/megamek/client/ui/swing/MapMenu.java index 366106147d1..4b26b4dcb6c 100644 --- a/megamek/src/megamek/client/ui/swing/MapMenu.java +++ b/megamek/src/megamek/client/ui/swing/MapMenu.java @@ -23,7 +23,6 @@ import java.awt.event.ActionEvent; import java.awt.event.InputEvent; import java.awt.event.MouseEvent; -import java.math.BigInteger; import java.util.*; import javax.swing.*; @@ -1612,7 +1611,7 @@ private boolean hasAmmoType(int ammoType) { return false; } - private boolean hasWeaponFlag(BigInteger weaponFlag) { + private boolean hasWeaponFlag(IndexedFlag weaponFlag) { if (myEntity.getWeaponList().isEmpty()) { return false; } diff --git a/megamek/src/megamek/common/AmmoType.java b/megamek/src/megamek/common/AmmoType.java index c302571e39e..4d88c1b2460 100644 --- a/megamek/src/megamek/common/AmmoType.java +++ b/megamek/src/megamek/common/AmmoType.java @@ -14,7 +14,6 @@ */ package megamek.common; -import java.math.BigInteger; import java.util.ArrayList; import java.util.EnumSet; import java.util.Enumeration; @@ -182,42 +181,42 @@ public class AmmoType extends EquipmentType { public static final Set ALLOWED_BY_TYPE = Set.of(ALLOWED_BY_TYPE_ARRAY); // ammo flags - public static final BigInteger F_MG = BigInteger.valueOf(1).shiftLeft(0); - public static final BigInteger F_BATTLEARMOR = BigInteger.valueOf(1).shiftLeft(1); // only used by BA squads - public static final BigInteger F_PROTOMEK = BigInteger.valueOf(1).shiftLeft(2); // only used by ProtoMeks - public static final BigInteger F_HOTLOAD = BigInteger.valueOf(1).shiftLeft(3); // Ammo can be hotloaded + public static final AmmoTypeFlag F_MG = AmmoTypeFlag.F_MG; + public static final AmmoTypeFlag F_BATTLEARMOR = AmmoTypeFlag.F_BATTLEARMOR; // only used by BA squads + public static final AmmoTypeFlag F_PROTOMEK = AmmoTypeFlag.F_PROTOMEK; // only used by ProtoMeks + public static final AmmoTypeFlag F_HOTLOAD = AmmoTypeFlag.F_HOTLOAD; // Ammo can be hotloaded // BA can't jump or make anti-mek until dumped - public static final BigInteger F_ENCUMBERING = BigInteger.valueOf(1).shiftLeft(4); - - public static final BigInteger F_MML_LRM = BigInteger.valueOf(1).shiftLeft(5); // LRM type - public static final BigInteger F_AR10_WHITE_SHARK = BigInteger.valueOf(1).shiftLeft(6); // White shark type - public static final BigInteger F_AR10_KILLER_WHALE = BigInteger.valueOf(1).shiftLeft(7); // Killer Whale type - public static final BigInteger F_AR10_BARRACUDA = BigInteger.valueOf(1).shiftLeft(8); // barracuda type - public static final BigInteger F_NUCLEAR = BigInteger.valueOf(1).shiftLeft(9); // Nuclear missile - public static final BigInteger F_SANTA_ANNA = BigInteger.valueOf(1).shiftLeft(14); // Santa Anna Missile - public static final BigInteger F_PEACEMAKER = BigInteger.valueOf(1).shiftLeft(15); // Peacemaker Missile - public static final BigInteger F_TELE_MISSILE = BigInteger.valueOf(1).shiftLeft(10); // Tele-Missile - public static final BigInteger F_CAP_MISSILE = BigInteger.valueOf(1).shiftLeft(11); // Other Capital-Missile - public static final BigInteger F_SPACE_BOMB = BigInteger.valueOf(1).shiftLeft(12); // can be used to space bomb + public static final AmmoTypeFlag F_ENCUMBERING = AmmoTypeFlag.F_ENCUMBERING; + + public static final AmmoTypeFlag F_MML_LRM = AmmoTypeFlag.F_MML_LRM; // LRM type + public static final AmmoTypeFlag F_AR10_WHITE_SHARK = AmmoTypeFlag.F_AR10_WHITE_SHARK; // White shark type + public static final AmmoTypeFlag F_AR10_KILLER_WHALE = AmmoTypeFlag.F_AR10_KILLER_WHALE; // Killer Whale type + public static final AmmoTypeFlag F_AR10_BARRACUDA = AmmoTypeFlag.F_AR10_BARRACUDA; // barracuda type + public static final AmmoTypeFlag F_NUCLEAR = AmmoTypeFlag.F_NUCLEAR; // Nuclear missile + public static final AmmoTypeFlag F_SANTA_ANNA = AmmoTypeFlag.F_SANTA_ANNA; // Santa Anna Missile + public static final AmmoTypeFlag F_PEACEMAKER = AmmoTypeFlag.F_PEACEMAKER; // Peacemaker Missile + public static final AmmoTypeFlag F_TELE_MISSILE = AmmoTypeFlag.F_TELE_MISSILE; // Tele-Missile + public static final AmmoTypeFlag F_CAP_MISSILE = AmmoTypeFlag.F_CAP_MISSILE; // Other Capital-Missile + public static final AmmoTypeFlag F_SPACE_BOMB = AmmoTypeFlag.F_SPACE_BOMB; // can be used to space bomb // can be used to ground bomb - public static final BigInteger F_GROUND_BOMB = BigInteger.valueOf(1).shiftLeft(13); - public static final BigInteger F_MML_SRM = BigInteger.valueOf(1).shiftLeft(14); // SRM type + public static final AmmoTypeFlag F_GROUND_BOMB = AmmoTypeFlag.F_GROUND_BOMB; + public static final AmmoTypeFlag F_MML_SRM = AmmoTypeFlag.F_MML_SRM; // SRM type // Numbers 14-15 out of order. See nuclear missiles, above // For tag, rl pods, missiles and the like - public static final BigInteger F_OTHER_BOMB = BigInteger.valueOf(1).shiftLeft(16); + public static final AmmoTypeFlag F_OTHER_BOMB = AmmoTypeFlag.F_OTHER_BOMB; // Used by MHQ for loading ammo bins - public static final BigInteger F_CRUISE_MISSILE = BigInteger.valueOf(1).shiftLeft(17); + public static final AmmoTypeFlag F_CRUISE_MISSILE = AmmoTypeFlag.F_CRUISE_MISSILE; // Used by MHQ for loading ammo bins - public static final BigInteger F_SCREEN = BigInteger.valueOf(1).shiftLeft(18); + public static final AmmoTypeFlag F_SCREEN = AmmoTypeFlag.F_SCREEN; // Used for Internal Bomb Bay bombs; to differentiate them from - public static final BigInteger F_INTERNAL_BOMB = BigInteger.valueOf(1).shiftLeft(19); + public static final AmmoTypeFlag F_INTERNAL_BOMB = AmmoTypeFlag.F_INTERNAL_BOMB; // ammo munitions, used for custom load outs // N.B. We use EnumSet allow "incendiary" diff --git a/megamek/src/megamek/common/AmmoTypeFlag.java b/megamek/src/megamek/common/AmmoTypeFlag.java new file mode 100644 index 00000000000..309024eeccc --- /dev/null +++ b/megamek/src/megamek/common/AmmoTypeFlag.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2025 - The MegaMek Team. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ +package megamek.common; + +/** + * @author Luana Coppio + */ +public enum AmmoTypeFlag implements IndexedFlag { + + // ammo flags + F_MG(0), + F_BATTLEARMOR(1), // only used by BA squads + F_PROTOMEK(2), // only used by ProtoMeks + F_HOTLOAD(3), // Ammo can be hotloaded + + // BA can't jump or make anti-mek until dumped + F_ENCUMBERING(4), + + F_MML_LRM(5), // LRM type + F_AR10_WHITE_SHARK(6), // White shark type + F_AR10_KILLER_WHALE(7), // Killer Whale type + F_AR10_BARRACUDA(8), // barracuda type + F_NUCLEAR(9), // Nuclear missile + F_SANTA_ANNA(14), // Santa Anna Missile + F_PEACEMAKER(15), // Peacemaker Missile + F_TELE_MISSILE(10), // Tele-Missile + F_CAP_MISSILE(11), // Other Capital-Missile + F_SPACE_BOMB(12), // can be used to space bomb + + // can be used to ground bomb + F_GROUND_BOMB(13), + F_MML_SRM(14), // SRM type + + // Numbers 14-15 out of order. See nuclear missiles, above + + // For tag, rl pods, missiles and the like + F_OTHER_BOMB(16), + + // Used by MHQ for loading ammo bins + F_CRUISE_MISSILE(17), + + // Used by MHQ for loading ammo bins + F_SCREEN(18), + + // Used for Internal Bomb Bay bombs; to differentiate them from + F_INTERNAL_BOMB(19); + + private final int flagIndex; + + AmmoTypeFlag(int flagIndex) { + assert flagIndex >= 0; + this.flagIndex = flagIndex; + } + + @Override + public int getFlagIndex() { + return flagIndex; + } + +} diff --git a/megamek/src/megamek/common/Entity.java b/megamek/src/megamek/common/Entity.java index fa40dabd88d..ea463a715b4 100644 --- a/megamek/src/megamek/common/Entity.java +++ b/megamek/src/megamek/common/Entity.java @@ -50,7 +50,6 @@ import megamek.utilities.xml.MMXMLUtility; import java.awt.*; -import java.math.BigInteger; import java.util.List; import java.util.*; import java.util.concurrent.ConcurrentHashMap; @@ -4470,7 +4469,7 @@ public List getBombs() { * @return The list of found bombs * @see Mounted#isOperable() */ - public List getBombs(BigInteger flag) { + public List getBombs(IndexedFlag flag) { return getBombs().stream() .filter(b -> b.getType().hasFlag(flag)) .filter(Mounted::isOperable) @@ -4632,7 +4631,7 @@ public List getClubs() { * @param flag A MiscType.F_XXX * @return true if at least one ready item. */ - public boolean hasWorkingMisc(BigInteger flag) { + public boolean hasWorkingMisc(IndexedFlag flag) { return hasWorkingMisc(flag, -1); } @@ -4643,7 +4642,7 @@ public boolean hasWorkingMisc(BigInteger flag) { * @param secondary A MiscType.S_XXX or -1 for don't care * @return true if at least one ready item. */ - public boolean hasWorkingMisc(BigInteger flag, long secondary) { + public boolean hasWorkingMisc(IndexedFlag flag, long secondary) { for (MiscMounted m : miscList) { if (m.isReady() && m.getType().hasFlag(flag) && ((secondary == -1) || m.getType().hasSubType(secondary))) { @@ -4653,11 +4652,11 @@ public boolean hasWorkingMisc(BigInteger flag, long secondary) { return false; } - public boolean hasMisc(BigInteger flag) { + public boolean hasMisc(IndexedFlag flag) { return miscList.stream().anyMatch(misc -> misc.getType().hasFlag(flag)); } - public List getMiscEquipment(BigInteger flag) { + public List getMiscEquipment(IndexedFlag flag) { return miscList.stream() .filter(item -> item.getType().hasFlag(flag)) .collect(Collectors.toList()); @@ -4682,11 +4681,11 @@ public long countEquipment(String internalName) { * @param flag * @return */ - public int countWorkingMisc(BigInteger flag) { + public int countWorkingMisc(IndexedFlag flag) { return countWorkingMisc(flag, -1); } - public int countWorkingMisc(BigInteger flag, int location) { + public int countWorkingMisc(IndexedFlag flag, int location) { int count = 0; OUTER: for (MiscMounted m : getMisc()) { if (!m.isInoperable() && m.getType().hasFlag(flag) @@ -4745,7 +4744,7 @@ public boolean hasWorkingMisc(String name) { * @param location The location to check e.g. Mek.LOC_LARM * @return true if at least one ready item. */ - public boolean hasWorkingMisc(BigInteger flag, long secondary, int location) { + public boolean hasWorkingMisc(IndexedFlag flag, long secondary, int location) { // go through the location slot by slot, because of misc equipment that // is spreadable for (int slot = 0; slot < getNumberOfCriticals(location); slot++) { diff --git a/megamek/src/megamek/common/EquipmentBitSet.java b/megamek/src/megamek/common/EquipmentBitSet.java new file mode 100644 index 00000000000..9faa551af6b --- /dev/null +++ b/megamek/src/megamek/common/EquipmentBitSet.java @@ -0,0 +1,129 @@ +package megamek.common; + +import java.util.BitSet; +import java.util.Objects; + +/** + * Represents a set of flags that can be used to represent the type and + * special properties of the equipment. + * @author Luana Coppio + */ +public class EquipmentBitSet { + + private final BitSet bitSet; + + /** + * Default constructor. + */ + public EquipmentBitSet() { + this.bitSet = new BitSet(MiscTypeFlag.values().length + AmmoTypeFlag.values().length + WeaponTypeFlag.values().length); + } + + /** + * Copy constructor. + * @param other the EquipmentBitSet to copy + */ + public EquipmentBitSet(EquipmentBitSet other) { + this.bitSet = (BitSet) other.bitSet.clone(); + } + + /** + * Returns true if the flag is set in the EquipmentBitSet. + * @param flag the flag to check + * @return true if the flag is set in the EquipmentBitSet + */ + public boolean get(IndexedFlag flag) { + return bitSet.get(flag.getFlagIndex()); + } + + public boolean contains(EquipmentBitSet other) { + var checker = new EquipmentBitSet(this); + checker.bitSet.and(other.bitSet); + return checker.equals(other); + } + + /** + * Clears the flag in the EquipmentBitSet. + * @param flag the flag to clear + */ + public void clear(IndexedFlag flag) { + bitSet.clear(flag.getFlagIndex()); + } + + /** + * Clears all flags in the EquipmentBitSet. + */ + public void clear() { + bitSet.clear(); + } + + /** + * Sets the flag in the EquipmentBitSet. + * @param flag the flag to set + */ + public void set(IndexedFlag flag) { + bitSet.set(flag.getFlagIndex()); + } + + + /** + * Returns a copy of this EquipmentBitSet with the flag set. + * @param flag the flag to set + * @return a copy of this EquipmentBitSet with the flag set + */ + public EquipmentBitSet or(IndexedFlag flag) { + var newBitSet = new EquipmentBitSet(this); + newBitSet.set(flag); + return newBitSet; + } + + /** + * Returns a copy of this EquipmentBitSet with the flag cleared. + * @param flag the flag to clear + * @return a copy of this EquipmentBitSet with the flag cleared + */ + public EquipmentBitSet andNot(IndexedFlag flag) { + var newBitSet = new EquipmentBitSet(this); + newBitSet.clear(flag); + return newBitSet; + } + + /** + * Returns a new empty EquipmentBitSet and the flag set if it is set in this EquipmentBitSet. + * Example: + * EquipmentBitSet a = new EquipmentBitSet(); + * a.set(F_HEAT_SINK); + * a.set(F_DOUBLE_HEATSINK); + * a.and(F_HEAT_SINK) // EquipmentBitSet with only F_HEAT_SINK set if it was originally set + * a.has(F_HEAT_SINK); // true + * a.has(F_DOUBLE_HEATSINK); // false + * @param flag the flag to check + * @return a new empty EquipmentBitSet and the flag set if it is set in this EquipmentBitSet + */ + public EquipmentBitSet and(IndexedFlag flag) { + var newBitSet = new EquipmentBitSet(); + if (this.get(flag)) { + newBitSet.set(flag); + } + return newBitSet; + } + + @Override + public String toString() { + return "EntityBitSet{" + + "bitSet=" + bitSet + + '}'; + } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + EquipmentBitSet that = (EquipmentBitSet) o; + return Objects.equals(bitSet, that.bitSet); + } + + @Override + public int hashCode() { + return Objects.hashCode(bitSet); + } +} diff --git a/megamek/src/megamek/common/EquipmentType.java b/megamek/src/megamek/common/EquipmentType.java index da38aa2f65e..2d47a7789f1 100644 --- a/megamek/src/megamek/common/EquipmentType.java +++ b/megamek/src/megamek/common/EquipmentType.java @@ -17,7 +17,6 @@ import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; -import java.math.BigInteger; import java.util.*; import java.util.stream.Collectors; @@ -161,7 +160,7 @@ public class EquipmentType implements ITechnology { protected TechAdvancement techAdvancement = new TechAdvancement(); - protected BigInteger flags = BigInteger.ZERO; + protected EquipmentBitSet flags = new EquipmentBitSet(); protected long subType = 0; @@ -201,8 +200,8 @@ public EquipmentType() { // default constructor } - public void setFlags(BigInteger inF) { - flags = inF; + public void setFlags(EquipmentBitSet flags) { + this.flags = flags; } public long getSubType() { @@ -506,12 +505,21 @@ public int getToHitModifier(@Nullable Mounted mounted) { return toHitModifier; } - public BigInteger getFlags() { + public EquipmentBitSet getFlags() { return flags; } - public boolean hasFlag(BigInteger flag) { - return !(flags.and(flag)).equals(BigInteger.ZERO); + public boolean hasFlag(IndexedFlag flag) { + return flags.get(flag); + } + + /** + * Checks if the equipment has all of the specified flags. + * @param flag The flags to check + * @return True if the equipment has all of the specified flags + */ + public boolean hasFlag(EquipmentBitSet flag) { + return flags.contains(flag); } public double getBV(Entity entity) { diff --git a/megamek/src/megamek/common/IndexedFlag.java b/megamek/src/megamek/common/IndexedFlag.java new file mode 100644 index 00000000000..7bb1096f841 --- /dev/null +++ b/megamek/src/megamek/common/IndexedFlag.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 - The MegaMek Team. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ +package megamek.common; + + +/** + * Interface for entity flags, used by {@link EquipmentBitSet}. + * Allows for easy flag manipulation with enums that implement this interface. + * Also provides a default method to convert a single flag to a bitset so + * multiple flags can be composed into an {@link EquipmentBitSet}. + * @author Luana Coppio + */ +public interface IndexedFlag { + /** + * Returns the index of the flag in the bitset + * - Future improvements, return ordinal instead of arbitrary index + * @return the index of the flag in the bitset + */ + int getFlagIndex(); + + /** + * Converts this flag to an {@link EquipmentBitSet}. + * @return an {@link EquipmentBitSet} with this flag set + */ + default EquipmentBitSet asEquipmentBitSet() { + return new EquipmentBitSet().or(this); + } +} diff --git a/megamek/src/megamek/common/Mek.java b/megamek/src/megamek/common/Mek.java index 9eb4ee92477..7e9fff6ad18 100644 --- a/megamek/src/megamek/common/Mek.java +++ b/megamek/src/megamek/common/Mek.java @@ -16,7 +16,6 @@ package megamek.common; import java.io.PrintWriter; -import java.math.BigInteger; import java.time.LocalDate; import java.util.ArrayList; import java.util.HashMap; @@ -1392,7 +1391,7 @@ public int height() { * Adds heat sinks to the engine. Uses clan/normal depending on the * currently set techLevel */ - public void addEngineSinks(int totalSinks, BigInteger heatSinkFlag) { + public void addEngineSinks(int totalSinks, IndexedFlag heatSinkFlag) { addEngineSinks(totalSinks, heatSinkFlag, isClan()); } @@ -1400,7 +1399,7 @@ public void addEngineSinks(int totalSinks, BigInteger heatSinkFlag) { * Adds heat sinks to the engine. Adds either the engine capacity, or the * entire number of heat sinks, whichever is less */ - public void addEngineSinks(int totalSinks, BigInteger heatSinkFlag, + public void addEngineSinks(int totalSinks, IndexedFlag heatSinkFlag, boolean clan) { if (heatSinkFlag == MiscType.F_DOUBLE_HEAT_SINK) { addEngineSinks(totalSinks, clan ? EquipmentTypeLookup.CLAN_DOUBLE_HS diff --git a/megamek/src/megamek/common/MiscType.java b/megamek/src/megamek/common/MiscType.java index 338940e017a..1ef80e9b2f8 100644 --- a/megamek/src/megamek/common/MiscType.java +++ b/megamek/src/megamek/common/MiscType.java @@ -14,7 +14,6 @@ */ package megamek.common; -import java.math.BigInteger; import java.text.NumberFormat; import megamek.common.equipment.MiscMounted; @@ -34,257 +33,257 @@ public class MiscType extends EquipmentType { // equipment flags (okay, like every type of equipment has its own flag) - public static final BigInteger F_HEAT_SINK = BigInteger.valueOf(1).shiftLeft(0); - public static final BigInteger F_DOUBLE_HEAT_SINK = BigInteger.valueOf(1).shiftLeft(1); - public static final BigInteger F_JUMP_JET = BigInteger.valueOf(1).shiftLeft(2); - public static final BigInteger F_CASE = BigInteger.valueOf(1).shiftLeft(3); - public static final BigInteger F_MASC = BigInteger.valueOf(1).shiftLeft(4); - public static final BigInteger F_TSM = BigInteger.valueOf(1).shiftLeft(5); - public static final BigInteger F_LASER_HEAT_SINK = BigInteger.valueOf(1).shiftLeft(6); - public static final BigInteger F_C3S = BigInteger.valueOf(1).shiftLeft(7); - public static final BigInteger F_C3I = BigInteger.valueOf(1).shiftLeft(8); - public static final BigInteger F_ARTEMIS = BigInteger.valueOf(1).shiftLeft(9); - public static final BigInteger F_TARGCOMP = BigInteger.valueOf(1).shiftLeft(10); - public static final BigInteger F_ANGEL_ECM = BigInteger.valueOf(1).shiftLeft(11); - public static final BigInteger F_BOARDING_CLAW = BigInteger.valueOf(1).shiftLeft(12); - public static final BigInteger F_VACUUM_PROTECTION = BigInteger.valueOf(1).shiftLeft(13); - public static final BigInteger F_MAGNET_CLAW = BigInteger.valueOf(1).shiftLeft(14); - public static final BigInteger F_FIRE_RESISTANT = BigInteger.valueOf(1).shiftLeft(15); - public static final BigInteger F_STEALTH = BigInteger.valueOf(1).shiftLeft(16); - public static final BigInteger F_MINE = BigInteger.valueOf(1).shiftLeft(17); - public static final BigInteger F_TOOLS = BigInteger.valueOf(1).shiftLeft(18); - public static final BigInteger F_MAGNETIC_CLAMP = BigInteger.valueOf(1).shiftLeft(19); - public static final BigInteger F_PARAFOIL = BigInteger.valueOf(1).shiftLeft(20); - public static final BigInteger F_FERRO_FIBROUS = BigInteger.valueOf(1).shiftLeft(21); - public static final BigInteger F_ENDO_STEEL = BigInteger.valueOf(1).shiftLeft(22); - public static final BigInteger F_AP_POD = BigInteger.valueOf(1).shiftLeft(23); - public static final BigInteger F_SEARCHLIGHT = BigInteger.valueOf(1).shiftLeft(24); - public static final BigInteger F_CLUB = BigInteger.valueOf(1).shiftLeft(25); - public static final BigInteger F_HAND_WEAPON = BigInteger.valueOf(1).shiftLeft(26); - public static final BigInteger F_COWL = BigInteger.valueOf(1).shiftLeft(27); - public static final BigInteger F_JUMP_BOOSTER = BigInteger.valueOf(1).shiftLeft(28); - public static final BigInteger F_HARJEL = BigInteger.valueOf(1).shiftLeft(29); - public static final BigInteger F_UMU = BigInteger.valueOf(1).shiftLeft(30); - public static final BigInteger F_BA_VTOL = BigInteger.valueOf(1).shiftLeft(31); - public static final BigInteger F_SPIKES = BigInteger.valueOf(1).shiftLeft(32); - public static final BigInteger F_COMMUNICATIONS = BigInteger.valueOf(1).shiftLeft(33); - public static final BigInteger F_PPC_CAPACITOR = BigInteger.valueOf(1).shiftLeft(34); - public static final BigInteger F_REFLECTIVE = BigInteger.valueOf(1).shiftLeft(35); - public static final BigInteger F_REACTIVE = BigInteger.valueOf(1).shiftLeft(36); - public static final BigInteger F_CASEII = BigInteger.valueOf(1).shiftLeft(37); - public static final BigInteger F_LIFTHOIST = BigInteger.valueOf(1).shiftLeft(38); - public static final BigInteger F_ENVIRONMENTAL_SEALING = BigInteger.valueOf(1).shiftLeft(39); - public static final BigInteger F_ARMORED_CHASSIS = BigInteger.valueOf(1).shiftLeft(40); - public static final BigInteger F_TRACTOR_MODIFICATION = BigInteger.valueOf(1).shiftLeft(41); - public static final BigInteger F_ACTUATOR_ENHANCEMENT_SYSTEM = BigInteger.valueOf(1).shiftLeft(42); - public static final BigInteger F_ECM = BigInteger.valueOf(1).shiftLeft(43); - public static final BigInteger F_BAP = BigInteger.valueOf(1).shiftLeft(44); - public static final BigInteger F_MODULAR_ARMOR = BigInteger.valueOf(1).shiftLeft(45); - public static final BigInteger F_TALON = BigInteger.valueOf(1).shiftLeft(46); - public static final BigInteger F_VISUAL_CAMO = BigInteger.valueOf(1).shiftLeft(47); - public static final BigInteger F_APOLLO = BigInteger.valueOf(1).shiftLeft(48); - public static final BigInteger F_INDUSTRIAL_TSM = BigInteger.valueOf(1).shiftLeft(49); - public static final BigInteger F_NULLSIG = BigInteger.valueOf(1).shiftLeft(50); - public static final BigInteger F_VOIDSIG = BigInteger.valueOf(1).shiftLeft(51); - public static final BigInteger F_CHAMELEON_SHIELD = BigInteger.valueOf(1).shiftLeft(52); - public static final BigInteger F_VIBROCLAW = BigInteger.valueOf(1).shiftLeft(53); - public static final BigInteger F_SINGLE_HEX_ECM = BigInteger.valueOf(1).shiftLeft(54); - public static final BigInteger F_EJECTION_SEAT = BigInteger.valueOf(1).shiftLeft(55); - public static final BigInteger F_SALVAGE_ARM = BigInteger.valueOf(1).shiftLeft(56); - public static final BigInteger F_PARTIAL_WING = BigInteger.valueOf(1).shiftLeft(57); - public static final BigInteger F_FERRO_LAMELLOR = BigInteger.valueOf(1).shiftLeft(58); - public static final BigInteger F_ARTEMIS_V = BigInteger.valueOf(1).shiftLeft(59); + public static final MiscTypeFlag F_HEAT_SINK = MiscTypeFlag.F_HEAT_SINK; + public static final MiscTypeFlag F_DOUBLE_HEAT_SINK = MiscTypeFlag.F_DOUBLE_HEAT_SINK; + public static final MiscTypeFlag F_JUMP_JET = MiscTypeFlag.F_JUMP_JET; + public static final MiscTypeFlag F_CASE = MiscTypeFlag.F_CASE; + public static final MiscTypeFlag F_MASC = MiscTypeFlag.F_MASC; + public static final MiscTypeFlag F_TSM = MiscTypeFlag.F_TSM; + public static final MiscTypeFlag F_LASER_HEAT_SINK = MiscTypeFlag.F_LASER_HEAT_SINK; + public static final MiscTypeFlag F_C3S = MiscTypeFlag.F_C3S; + public static final MiscTypeFlag F_C3I = MiscTypeFlag.F_C3I; + public static final MiscTypeFlag F_ARTEMIS = MiscTypeFlag.F_ARTEMIS; + public static final MiscTypeFlag F_TARGCOMP = MiscTypeFlag.F_TARGCOMP; + public static final MiscTypeFlag F_ANGEL_ECM = MiscTypeFlag.F_ANGEL_ECM; + public static final MiscTypeFlag F_BOARDING_CLAW = MiscTypeFlag.F_BOARDING_CLAW; + public static final MiscTypeFlag F_VACUUM_PROTECTION = MiscTypeFlag.F_VACUUM_PROTECTION; + public static final MiscTypeFlag F_MAGNET_CLAW = MiscTypeFlag.F_MAGNET_CLAW; + public static final MiscTypeFlag F_FIRE_RESISTANT = MiscTypeFlag.F_FIRE_RESISTANT; + public static final MiscTypeFlag F_STEALTH = MiscTypeFlag.F_STEALTH; + public static final MiscTypeFlag F_MINE = MiscTypeFlag.F_MINE; + public static final MiscTypeFlag F_TOOLS = MiscTypeFlag.F_TOOLS; + public static final MiscTypeFlag F_MAGNETIC_CLAMP = MiscTypeFlag.F_MAGNETIC_CLAMP; + public static final MiscTypeFlag F_PARAFOIL = MiscTypeFlag.F_PARAFOIL; + public static final MiscTypeFlag F_FERRO_FIBROUS = MiscTypeFlag.F_FERRO_FIBROUS; + public static final MiscTypeFlag F_ENDO_STEEL = MiscTypeFlag.F_ENDO_STEEL; + public static final MiscTypeFlag F_AP_POD = MiscTypeFlag.F_AP_POD; + public static final MiscTypeFlag F_SEARCHLIGHT = MiscTypeFlag.F_SEARCHLIGHT; + public static final MiscTypeFlag F_CLUB = MiscTypeFlag.F_CLUB; + public static final MiscTypeFlag F_HAND_WEAPON = MiscTypeFlag.F_HAND_WEAPON; + public static final MiscTypeFlag F_COWL = MiscTypeFlag.F_COWL; + public static final MiscTypeFlag F_JUMP_BOOSTER = MiscTypeFlag.F_JUMP_BOOSTER; + public static final MiscTypeFlag F_HARJEL = MiscTypeFlag.F_HARJEL; + public static final MiscTypeFlag F_UMU = MiscTypeFlag.F_UMU; + public static final MiscTypeFlag F_BA_VTOL = MiscTypeFlag.F_BA_VTOL; + public static final MiscTypeFlag F_SPIKES = MiscTypeFlag.F_SPIKES; + public static final MiscTypeFlag F_COMMUNICATIONS = MiscTypeFlag.F_COMMUNICATIONS; + public static final MiscTypeFlag F_PPC_CAPACITOR = MiscTypeFlag.F_PPC_CAPACITOR; + public static final MiscTypeFlag F_REFLECTIVE = MiscTypeFlag.F_REFLECTIVE; + public static final MiscTypeFlag F_REACTIVE = MiscTypeFlag.F_REACTIVE; + public static final MiscTypeFlag F_CASEII = MiscTypeFlag.F_CASEII; + public static final MiscTypeFlag F_LIFTHOIST = MiscTypeFlag.F_LIFTHOIST; + public static final MiscTypeFlag F_ENVIRONMENTAL_SEALING = MiscTypeFlag.F_ENVIRONMENTAL_SEALING; + public static final MiscTypeFlag F_ARMORED_CHASSIS = MiscTypeFlag.F_ARMORED_CHASSIS; + public static final MiscTypeFlag F_TRACTOR_MODIFICATION = MiscTypeFlag.F_TRACTOR_MODIFICATION; + public static final MiscTypeFlag F_ACTUATOR_ENHANCEMENT_SYSTEM = MiscTypeFlag.F_ACTUATOR_ENHANCEMENT_SYSTEM; + public static final MiscTypeFlag F_ECM = MiscTypeFlag.F_ECM; + public static final MiscTypeFlag F_BAP = MiscTypeFlag.F_BAP; + public static final MiscTypeFlag F_MODULAR_ARMOR = MiscTypeFlag.F_MODULAR_ARMOR; + public static final MiscTypeFlag F_TALON = MiscTypeFlag.F_TALON; + public static final MiscTypeFlag F_VISUAL_CAMO = MiscTypeFlag.F_VISUAL_CAMO; + public static final MiscTypeFlag F_APOLLO = MiscTypeFlag.F_APOLLO; + public static final MiscTypeFlag F_INDUSTRIAL_TSM = MiscTypeFlag.F_INDUSTRIAL_TSM; + public static final MiscTypeFlag F_NULLSIG = MiscTypeFlag.F_NULLSIG; + public static final MiscTypeFlag F_VOIDSIG = MiscTypeFlag.F_VOIDSIG; + public static final MiscTypeFlag F_CHAMELEON_SHIELD = MiscTypeFlag.F_CHAMELEON_SHIELD; + public static final MiscTypeFlag F_VIBROCLAW = MiscTypeFlag.F_VIBROCLAW; + public static final MiscTypeFlag F_SINGLE_HEX_ECM = MiscTypeFlag.F_SINGLE_HEX_ECM; + public static final MiscTypeFlag F_EJECTION_SEAT = MiscTypeFlag.F_EJECTION_SEAT; + public static final MiscTypeFlag F_SALVAGE_ARM = MiscTypeFlag.F_SALVAGE_ARM; + public static final MiscTypeFlag F_PARTIAL_WING = MiscTypeFlag.F_PARTIAL_WING; + public static final MiscTypeFlag F_FERRO_LAMELLOR = MiscTypeFlag.F_FERRO_LAMELLOR; + public static final MiscTypeFlag F_ARTEMIS_V = MiscTypeFlag.F_ARTEMIS_V; // TODO: Implement me, so far only construction data - public static final BigInteger F_TRACKS = BigInteger.valueOf(1).shiftLeft(60); + public static final MiscTypeFlag F_TRACKS = MiscTypeFlag.F_TRACKS; // TODO: Implement me, so far only construction data - public static final BigInteger F_MASS = BigInteger.valueOf(1).shiftLeft(61); + public static final MiscTypeFlag F_MASS = MiscTypeFlag.F_MASS; // TODO: Implement me, so far only construction data - public static final BigInteger F_CARGO = BigInteger.valueOf(1).shiftLeft(62); + public static final MiscTypeFlag F_CARGO = MiscTypeFlag.F_CARGO; // TODO: Implement me, so far only construction data - public static final BigInteger F_DUMPER = BigInteger.valueOf(1).shiftLeft(63); + public static final MiscTypeFlag F_DUMPER = MiscTypeFlag.F_DUMPER; // TODO: Implement me, so far only construction data - public static final BigInteger F_MASH = BigInteger.valueOf(1).shiftLeft(64); - public static final BigInteger F_BA_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(65); - public static final BigInteger F_MEK_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(66); - public static final BigInteger F_TANK_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(67); - public static final BigInteger F_FIGHTER_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(68); - public static final BigInteger F_SUPPORT_TANK_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(69); - public static final BigInteger F_PROTOMEK_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(70); + public static final MiscTypeFlag F_MASH = MiscTypeFlag.F_MASH; + public static final MiscTypeFlag F_BA_EQUIPMENT = MiscTypeFlag.F_BA_EQUIPMENT; + public static final MiscTypeFlag F_MEK_EQUIPMENT = MiscTypeFlag.F_MEK_EQUIPMENT; + public static final MiscTypeFlag F_TANK_EQUIPMENT = MiscTypeFlag.F_TANK_EQUIPMENT; + public static final MiscTypeFlag F_FIGHTER_EQUIPMENT = MiscTypeFlag.F_FIGHTER_EQUIPMENT; + public static final MiscTypeFlag F_SUPPORT_TANK_EQUIPMENT = MiscTypeFlag.F_SUPPORT_TANK_EQUIPMENT; + public static final MiscTypeFlag F_PROTOMEK_EQUIPMENT = MiscTypeFlag.F_PROTOMEK_EQUIPMENT; // Moved the unit types to the top of the list. - public static final BigInteger F_ARMORED_GLOVE = BigInteger.valueOf(1).shiftLeft(71); - public static final BigInteger F_BASIC_MANIPULATOR = BigInteger.valueOf(1).shiftLeft(72); - public static final BigInteger F_BATTLE_CLAW = BigInteger.valueOf(1).shiftLeft(73); - public static final BigInteger F_AP_MOUNT = BigInteger.valueOf(1).shiftLeft(74); - public static final BigInteger F_MAST_MOUNT = BigInteger.valueOf(1).shiftLeft(75); - public static final BigInteger F_FUEL = BigInteger.valueOf(1).shiftLeft(76); - public static final BigInteger F_BLUE_SHIELD = BigInteger.valueOf(1).shiftLeft(77); - public static final BigInteger F_BASIC_FIRECONTROL = BigInteger.valueOf(1).shiftLeft(78); - public static final BigInteger F_ADVANCED_FIRECONTROL = BigInteger.valueOf(1).shiftLeft(79); - public static final BigInteger F_ENDO_COMPOSITE = BigInteger.valueOf(1).shiftLeft(80); - public static final BigInteger F_LASER_INSULATOR = BigInteger.valueOf(1).shiftLeft(81); - public static final BigInteger F_LIQUID_CARGO = BigInteger.valueOf(1).shiftLeft(82); - public static final BigInteger F_WATCHDOG = BigInteger.valueOf(1).shiftLeft(83); - public static final BigInteger F_EW_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(84); - public static final BigInteger F_CCM = BigInteger.valueOf(1).shiftLeft(85); - public static final BigInteger F_HITCH = BigInteger.valueOf(1).shiftLeft(86); - public static final BigInteger F_FLOTATION_HULL = BigInteger.valueOf(1).shiftLeft(87); - public static final BigInteger F_LIMITED_AMPHIBIOUS = BigInteger.valueOf(1).shiftLeft(88); - public static final BigInteger F_FULLY_AMPHIBIOUS = BigInteger.valueOf(1).shiftLeft(89); - public static final BigInteger F_DUNE_BUGGY = BigInteger.valueOf(1).shiftLeft(90); - public static final BigInteger F_SHOULDER_TURRET = BigInteger.valueOf(1).shiftLeft(91); - public static final BigInteger F_HEAD_TURRET = BigInteger.valueOf(1).shiftLeft(92); - public static final BigInteger F_QUAD_TURRET = BigInteger.valueOf(1).shiftLeft(93); - public static final BigInteger F_SPACE_ADAPTATION = BigInteger.valueOf(1).shiftLeft(94); - public static final BigInteger F_CUTTING_TORCH = BigInteger.valueOf(1).shiftLeft(95); - public static final BigInteger F_OFF_ROAD = BigInteger.valueOf(1).shiftLeft(96); - public static final BigInteger F_C3SBS = BigInteger.valueOf(1).shiftLeft(97); - public static final BigInteger F_VTOL_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(98); - public static final BigInteger F_NAVAL_C3 = BigInteger.valueOf(1).shiftLeft(99); - public static final BigInteger F_MINESWEEPER = BigInteger.valueOf(1).shiftLeft(100); - public static final BigInteger F_MOBILE_HPG = BigInteger.valueOf(1).shiftLeft(101); - public static final BigInteger F_FIELD_KITCHEN = BigInteger.valueOf(1).shiftLeft(102); - public static final BigInteger F_MOBILE_FIELD_BASE = BigInteger.valueOf(1).shiftLeft(103); + public static final MiscTypeFlag F_ARMORED_GLOVE = MiscTypeFlag.F_ARMORED_GLOVE; + public static final MiscTypeFlag F_BASIC_MANIPULATOR = MiscTypeFlag.F_BASIC_MANIPULATOR; + public static final MiscTypeFlag F_BATTLE_CLAW = MiscTypeFlag.F_BATTLE_CLAW; + public static final MiscTypeFlag F_AP_MOUNT = MiscTypeFlag.F_AP_MOUNT; + public static final MiscTypeFlag F_MAST_MOUNT = MiscTypeFlag.F_MAST_MOUNT; + public static final MiscTypeFlag F_FUEL = MiscTypeFlag.F_FUEL; + public static final MiscTypeFlag F_BLUE_SHIELD = MiscTypeFlag.F_BLUE_SHIELD; + public static final MiscTypeFlag F_BASIC_FIRECONTROL = MiscTypeFlag.F_BASIC_FIRECONTROL; + public static final MiscTypeFlag F_ADVANCED_FIRECONTROL = MiscTypeFlag.F_ADVANCED_FIRECONTROL; + public static final MiscTypeFlag F_ENDO_COMPOSITE = MiscTypeFlag.F_ENDO_COMPOSITE; + public static final MiscTypeFlag F_LASER_INSULATOR = MiscTypeFlag.F_LASER_INSULATOR; + public static final MiscTypeFlag F_LIQUID_CARGO = MiscTypeFlag.F_LIQUID_CARGO; + public static final MiscTypeFlag F_WATCHDOG = MiscTypeFlag.F_WATCHDOG; + public static final MiscTypeFlag F_EW_EQUIPMENT = MiscTypeFlag.F_EW_EQUIPMENT; + public static final MiscTypeFlag F_CCM = MiscTypeFlag.F_CCM; + public static final MiscTypeFlag F_HITCH = MiscTypeFlag.F_HITCH; + public static final MiscTypeFlag F_FLOTATION_HULL = MiscTypeFlag.F_FLOTATION_HULL; + public static final MiscTypeFlag F_LIMITED_AMPHIBIOUS = MiscTypeFlag.F_LIMITED_AMPHIBIOUS; + public static final MiscTypeFlag F_FULLY_AMPHIBIOUS = MiscTypeFlag.F_FULLY_AMPHIBIOUS; + public static final MiscTypeFlag F_DUNE_BUGGY = MiscTypeFlag.F_DUNE_BUGGY; + public static final MiscTypeFlag F_SHOULDER_TURRET = MiscTypeFlag.F_SHOULDER_TURRET; + public static final MiscTypeFlag F_HEAD_TURRET = MiscTypeFlag.F_HEAD_TURRET; + public static final MiscTypeFlag F_QUAD_TURRET = MiscTypeFlag.F_QUAD_TURRET; + public static final MiscTypeFlag F_SPACE_ADAPTATION = MiscTypeFlag.F_SPACE_ADAPTATION; + public static final MiscTypeFlag F_CUTTING_TORCH = MiscTypeFlag.F_CUTTING_TORCH; + public static final MiscTypeFlag F_OFF_ROAD = MiscTypeFlag.F_OFF_ROAD; + public static final MiscTypeFlag F_C3SBS = MiscTypeFlag.F_C3SBS; + public static final MiscTypeFlag F_VTOL_EQUIPMENT = MiscTypeFlag.F_VTOL_EQUIPMENT; + public static final MiscTypeFlag F_NAVAL_C3 = MiscTypeFlag.F_NAVAL_C3; + public static final MiscTypeFlag F_MINESWEEPER = MiscTypeFlag.F_MINESWEEPER; + public static final MiscTypeFlag F_MOBILE_HPG = MiscTypeFlag.F_MOBILE_HPG; + public static final MiscTypeFlag F_FIELD_KITCHEN = MiscTypeFlag.F_FIELD_KITCHEN; + public static final MiscTypeFlag F_MOBILE_FIELD_BASE = MiscTypeFlag.F_MOBILE_FIELD_BASE; // TODO: add game rules for the following imagers/radars, construction data // only - public static final BigInteger F_HIRES_IMAGER = BigInteger.valueOf(1).shiftLeft(104); - public static final BigInteger F_HYPERSPECTRAL_IMAGER = BigInteger.valueOf(1).shiftLeft(105); - public static final BigInteger F_INFRARED_IMAGER = BigInteger.valueOf(1).shiftLeft(106); - public static final BigInteger F_LOOKDOWN_RADAR = BigInteger.valueOf(1).shiftLeft(107); - - public static final BigInteger F_COMMAND_CONSOLE = BigInteger.valueOf(1).shiftLeft(108); - public static final BigInteger F_VSTOL_CHASSIS = BigInteger.valueOf(1).shiftLeft(109); - public static final BigInteger F_STOL_CHASSIS = BigInteger.valueOf(1).shiftLeft(110); - public static final BigInteger F_SPONSON_TURRET = BigInteger.valueOf(1).shiftLeft(111); - public static final BigInteger F_ARMORED_MOTIVE_SYSTEM = BigInteger.valueOf(1).shiftLeft(112); - public static final BigInteger F_CHASSIS_MODIFICATION = BigInteger.valueOf(1).shiftLeft(113); - public static final BigInteger F_CHAFF_POD = BigInteger.valueOf(1).shiftLeft(114); - public static final BigInteger F_DRONE_CARRIER_CONTROL = BigInteger.valueOf(1).shiftLeft(115); - public static final BigInteger F_VARIABLE_SIZE = BigInteger.valueOf(1).shiftLeft(116); - public static final BigInteger F_BA_MISSION_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(117); - public static final BigInteger F_JET_BOOSTER = BigInteger.valueOf(1).shiftLeft(118); - public static final BigInteger F_SENSOR_DISPENSER = BigInteger.valueOf(1).shiftLeft(119); - public static final BigInteger F_DRONE_OPERATING_SYSTEM = BigInteger.valueOf(1).shiftLeft(120); - public static final BigInteger F_RECON_CAMERA = BigInteger.valueOf(1).shiftLeft(121); - public static final BigInteger F_COMBAT_VEHICLE_ESCAPE_POD = BigInteger.valueOf(1).shiftLeft(122); - public static final BigInteger F_DETACHABLE_WEAPON_PACK = BigInteger.valueOf(1).shiftLeft(123); - public static final BigInteger F_HEAT_SENSOR = BigInteger.valueOf(1).shiftLeft(124); - public static final BigInteger F_EXTENDED_LIFESUPPORT = BigInteger.valueOf(1).shiftLeft(125); - public static final BigInteger F_SPRAYER = BigInteger.valueOf(1).shiftLeft(126); - public static final BigInteger F_ELECTRIC_DISCHARGE_ARMOR = BigInteger.valueOf(1).shiftLeft(127); - public static final BigInteger F_MECHANICAL_JUMP_BOOSTER = BigInteger.valueOf(1).shiftLeft(128); - public static final BigInteger F_TRAILER_MODIFICATION = BigInteger.valueOf(1).shiftLeft(129); - public static final BigInteger F_LARGE_COMM_SCANNER_SUITE = BigInteger.valueOf(1).shiftLeft(130); - public static final BigInteger F_SMALL_COMM_SCANNER_SUITE = BigInteger.valueOf(1).shiftLeft(131); - public static final BigInteger F_LIGHT_BRIDGE_LAYER = BigInteger.valueOf(1).shiftLeft(132); - public static final BigInteger F_MEDIUM_BRIDGE_LAYER = BigInteger.valueOf(1).shiftLeft(133); - public static final BigInteger F_HEAVY_BRIDGE_LAYER = BigInteger.valueOf(1).shiftLeft(134); - public static final BigInteger F_BA_SEARCHLIGHT = BigInteger.valueOf(1).shiftLeft(135); - public static final BigInteger F_BOOBY_TRAP = BigInteger.valueOf(1).shiftLeft(136); - public static final BigInteger F_SPLITABLE = BigInteger.valueOf(1).shiftLeft(137); - public static final BigInteger F_REFUELING_DROGUE = BigInteger.valueOf(1).shiftLeft(138); - public static final BigInteger F_BULLDOZER = BigInteger.valueOf(1).shiftLeft(139); - public static final BigInteger F_EXTERNAL_STORES_HARDPOINT = BigInteger.valueOf(1).shiftLeft(140); - public static final BigInteger F_COMPACT_HEAT_SINK = BigInteger.valueOf(1).shiftLeft(141); - public static final BigInteger F_MANIPULATOR = BigInteger.valueOf(1).shiftLeft(142); - public static final BigInteger F_CARGOLIFTER = BigInteger.valueOf(1).shiftLeft(143); - public static final BigInteger F_PINTLE_TURRET = BigInteger.valueOf(1).shiftLeft(144); - public static final BigInteger F_IS_DOUBLE_HEAT_SINK_PROTOTYPE = BigInteger.valueOf(1).shiftLeft(145); - public static final BigInteger F_NAVAL_TUG_ADAPTOR = BigInteger.valueOf(1).shiftLeft(146); - public static final BigInteger F_AMPHIBIOUS = BigInteger.valueOf(1).shiftLeft(147); - public static final BigInteger F_PROP = BigInteger.valueOf(1).shiftLeft(148); - public static final BigInteger F_ULTRA_LIGHT = BigInteger.valueOf(1).shiftLeft(149); - public static final BigInteger F_SPACE_MINE_DISPENSER = BigInteger.valueOf(1).shiftLeft(150); - public static final BigInteger F_VEHICLE_MINE_DISPENSER = BigInteger.valueOf(1).shiftLeft(151); - public static final BigInteger F_LIGHT_FERRO = BigInteger.valueOf(1).shiftLeft(152); - public static final BigInteger F_HEAVY_FERRO = BigInteger.valueOf(1).shiftLeft(153); - public static final BigInteger F_FERRO_FIBROUS_PROTO = BigInteger.valueOf(1).shiftLeft(154); - public static final BigInteger F_REINFORCED = BigInteger.valueOf(1).shiftLeft(155); - public static final BigInteger F_COMPOSITE = BigInteger.valueOf(1).shiftLeft(156); - public static final BigInteger F_INDUSTRIAL_STRUCTURE = BigInteger.valueOf(1).shiftLeft(157); - public static final BigInteger F_ENDO_STEEL_PROTO = BigInteger.valueOf(1).shiftLeft(158); - public static final BigInteger F_INDUSTRIAL_ARMOR = BigInteger.valueOf(1).shiftLeft(159); - public static final BigInteger F_HEAVY_INDUSTRIAL_ARMOR = BigInteger.valueOf(1).shiftLeft(160); - public static final BigInteger F_PRIMITIVE_ARMOR = BigInteger.valueOf(1).shiftLeft(161); - public static final BigInteger F_HARDENED_ARMOR = BigInteger.valueOf(1).shiftLeft(162); - public static final BigInteger F_COMMERCIAL_ARMOR = BigInteger.valueOf(1).shiftLeft(163); - public static final BigInteger F_C3EM = BigInteger.valueOf(1).shiftLeft(164); - public static final BigInteger F_ANTI_PENETRATIVE_ABLATIVE = BigInteger.valueOf(1).shiftLeft(165); - public static final BigInteger F_HEAT_DISSIPATING = BigInteger.valueOf(1).shiftLeft(166); - public static final BigInteger F_IMPACT_RESISTANT = BigInteger.valueOf(1).shiftLeft(167); - public static final BigInteger F_BALLISTIC_REINFORCED = BigInteger.valueOf(1).shiftLeft(168); - public static final BigInteger F_HARJEL_II = BigInteger.valueOf(1).shiftLeft(169); - public static final BigInteger F_HARJEL_III = BigInteger.valueOf(1).shiftLeft(170); - public static final BigInteger F_RADICAL_HEATSINK = BigInteger.valueOf(1).shiftLeft(171); - public static final BigInteger F_BA_MANIPULATOR = BigInteger.valueOf(1).shiftLeft(172); - public static final BigInteger F_NOVA = BigInteger.valueOf(1).shiftLeft(173); - public static final BigInteger F_BOMB_BAY = BigInteger.valueOf(1).shiftLeft(174); - public static final BigInteger F_LIGHT_FLUID_SUCTION_SYSTEM = BigInteger.valueOf(1).shiftLeft(175); - public static final BigInteger F_MONOCYCLE = BigInteger.valueOf(1).shiftLeft(176); - public static final BigInteger F_BICYCLE = BigInteger.valueOf(1).shiftLeft(177); - public static final BigInteger F_CONVERTIBLE = BigInteger.valueOf(1).shiftLeft(178); - public static final BigInteger F_BATTLEMEK_NIU = BigInteger.valueOf(1).shiftLeft(179); - public static final BigInteger F_SNOWMOBILE = BigInteger.valueOf(1).shiftLeft(180); - public static final BigInteger F_LADDER = BigInteger.valueOf(1).shiftLeft(181); - public static final BigInteger F_LIFEBOAT = BigInteger.valueOf(1).shiftLeft(182); - public static final BigInteger F_FLUID_SUCTION_SYSTEM = BigInteger.valueOf(1).shiftLeft(183); - public static final BigInteger F_HYDROFOIL = BigInteger.valueOf(1).shiftLeft(184); - public static final BigInteger F_SUBMERSIBLE = BigInteger.valueOf(1).shiftLeft(185); + public static final MiscTypeFlag F_HIRES_IMAGER = MiscTypeFlag.F_HIRES_IMAGER; + public static final MiscTypeFlag F_HYPERSPECTRAL_IMAGER = MiscTypeFlag.F_HYPERSPECTRAL_IMAGER; + public static final MiscTypeFlag F_INFRARED_IMAGER = MiscTypeFlag.F_INFRARED_IMAGER; + public static final MiscTypeFlag F_LOOKDOWN_RADAR = MiscTypeFlag.F_LOOKDOWN_RADAR; + + public static final MiscTypeFlag F_COMMAND_CONSOLE = MiscTypeFlag.F_COMMAND_CONSOLE; + public static final MiscTypeFlag F_VSTOL_CHASSIS = MiscTypeFlag.F_VSTOL_CHASSIS; + public static final MiscTypeFlag F_STOL_CHASSIS = MiscTypeFlag.F_STOL_CHASSIS; + public static final MiscTypeFlag F_SPONSON_TURRET = MiscTypeFlag.F_SPONSON_TURRET; + public static final MiscTypeFlag F_ARMORED_MOTIVE_SYSTEM = MiscTypeFlag.F_ARMORED_MOTIVE_SYSTEM; + public static final MiscTypeFlag F_CHASSIS_MODIFICATION = MiscTypeFlag.F_CHASSIS_MODIFICATION; + public static final MiscTypeFlag F_CHAFF_POD = MiscTypeFlag.F_CHAFF_POD; + public static final MiscTypeFlag F_DRONE_CARRIER_CONTROL = MiscTypeFlag.F_DRONE_CARRIER_CONTROL; + public static final MiscTypeFlag F_VARIABLE_SIZE = MiscTypeFlag.F_VARIABLE_SIZE; + public static final MiscTypeFlag F_BA_MISSION_EQUIPMENT = MiscTypeFlag.F_BA_MISSION_EQUIPMENT; + public static final MiscTypeFlag F_JET_BOOSTER = MiscTypeFlag.F_JET_BOOSTER; + public static final MiscTypeFlag F_SENSOR_DISPENSER = MiscTypeFlag.F_SENSOR_DISPENSER; + public static final MiscTypeFlag F_DRONE_OPERATING_SYSTEM = MiscTypeFlag.F_DRONE_OPERATING_SYSTEM; + public static final MiscTypeFlag F_RECON_CAMERA = MiscTypeFlag.F_RECON_CAMERA; + public static final MiscTypeFlag F_COMBAT_VEHICLE_ESCAPE_POD = MiscTypeFlag.F_COMBAT_VEHICLE_ESCAPE_POD; + public static final MiscTypeFlag F_DETACHABLE_WEAPON_PACK = MiscTypeFlag.F_DETACHABLE_WEAPON_PACK; + public static final MiscTypeFlag F_HEAT_SENSOR = MiscTypeFlag.F_HEAT_SENSOR; + public static final MiscTypeFlag F_EXTENDED_LIFESUPPORT = MiscTypeFlag.F_EXTENDED_LIFESUPPORT; + public static final MiscTypeFlag F_SPRAYER = MiscTypeFlag.F_SPRAYER; + public static final MiscTypeFlag F_ELECTRIC_DISCHARGE_ARMOR = MiscTypeFlag.F_ELECTRIC_DISCHARGE_ARMOR; + public static final MiscTypeFlag F_MECHANICAL_JUMP_BOOSTER = MiscTypeFlag.F_MECHANICAL_JUMP_BOOSTER; + public static final MiscTypeFlag F_TRAILER_MODIFICATION = MiscTypeFlag.F_TRAILER_MODIFICATION; + public static final MiscTypeFlag F_LARGE_COMM_SCANNER_SUITE = MiscTypeFlag.F_LARGE_COMM_SCANNER_SUITE; + public static final MiscTypeFlag F_SMALL_COMM_SCANNER_SUITE = MiscTypeFlag.F_SMALL_COMM_SCANNER_SUITE; + public static final MiscTypeFlag F_LIGHT_BRIDGE_LAYER = MiscTypeFlag.F_LIGHT_BRIDGE_LAYER; + public static final MiscTypeFlag F_MEDIUM_BRIDGE_LAYER = MiscTypeFlag.F_MEDIUM_BRIDGE_LAYER; + public static final MiscTypeFlag F_HEAVY_BRIDGE_LAYER = MiscTypeFlag.F_HEAVY_BRIDGE_LAYER; + public static final MiscTypeFlag F_BA_SEARCHLIGHT = MiscTypeFlag.F_BA_SEARCHLIGHT; + public static final MiscTypeFlag F_BOOBY_TRAP = MiscTypeFlag.F_BOOBY_TRAP; + public static final MiscTypeFlag F_SPLITABLE = MiscTypeFlag.F_SPLITABLE; + public static final MiscTypeFlag F_REFUELING_DROGUE = MiscTypeFlag.F_REFUELING_DROGUE; + public static final MiscTypeFlag F_BULLDOZER = MiscTypeFlag.F_BULLDOZER; + public static final MiscTypeFlag F_EXTERNAL_STORES_HARDPOINT = MiscTypeFlag.F_EXTERNAL_STORES_HARDPOINT; + public static final MiscTypeFlag F_COMPACT_HEAT_SINK = MiscTypeFlag.F_COMPACT_HEAT_SINK; + public static final MiscTypeFlag F_MANIPULATOR = MiscTypeFlag.F_MANIPULATOR; + public static final MiscTypeFlag F_CARGOLIFTER = MiscTypeFlag.F_CARGOLIFTER; + public static final MiscTypeFlag F_PINTLE_TURRET = MiscTypeFlag.F_PINTLE_TURRET; + public static final MiscTypeFlag F_IS_DOUBLE_HEAT_SINK_PROTOTYPE = MiscTypeFlag.F_IS_DOUBLE_HEAT_SINK_PROTOTYPE; + public static final MiscTypeFlag F_NAVAL_TUG_ADAPTOR = MiscTypeFlag.F_NAVAL_TUG_ADAPTOR; + public static final MiscTypeFlag F_AMPHIBIOUS = MiscTypeFlag.F_AMPHIBIOUS; + public static final MiscTypeFlag F_PROP = MiscTypeFlag.F_PROP; + public static final MiscTypeFlag F_ULTRA_LIGHT = MiscTypeFlag.F_ULTRA_LIGHT; + public static final MiscTypeFlag F_SPACE_MINE_DISPENSER = MiscTypeFlag.F_SPACE_MINE_DISPENSER; + public static final MiscTypeFlag F_VEHICLE_MINE_DISPENSER = MiscTypeFlag.F_VEHICLE_MINE_DISPENSER; + public static final MiscTypeFlag F_LIGHT_FERRO = MiscTypeFlag.F_LIGHT_FERRO; + public static final MiscTypeFlag F_HEAVY_FERRO = MiscTypeFlag.F_HEAVY_FERRO; + public static final MiscTypeFlag F_FERRO_FIBROUS_PROTO = MiscTypeFlag.F_FERRO_FIBROUS_PROTO; + public static final MiscTypeFlag F_REINFORCED = MiscTypeFlag.F_REINFORCED; + public static final MiscTypeFlag F_COMPOSITE = MiscTypeFlag.F_COMPOSITE; + public static final MiscTypeFlag F_INDUSTRIAL_STRUCTURE = MiscTypeFlag.F_INDUSTRIAL_STRUCTURE; + public static final MiscTypeFlag F_ENDO_STEEL_PROTO = MiscTypeFlag.F_ENDO_STEEL_PROTO; + public static final MiscTypeFlag F_INDUSTRIAL_ARMOR = MiscTypeFlag.F_INDUSTRIAL_ARMOR; + public static final MiscTypeFlag F_HEAVY_INDUSTRIAL_ARMOR = MiscTypeFlag.F_HEAVY_INDUSTRIAL_ARMOR; + public static final MiscTypeFlag F_PRIMITIVE_ARMOR = MiscTypeFlag.F_PRIMITIVE_ARMOR; + public static final MiscTypeFlag F_HARDENED_ARMOR = MiscTypeFlag.F_HARDENED_ARMOR; + public static final MiscTypeFlag F_COMMERCIAL_ARMOR = MiscTypeFlag.F_COMMERCIAL_ARMOR; + public static final MiscTypeFlag F_C3EM = MiscTypeFlag.F_C3EM; + public static final MiscTypeFlag F_ANTI_PENETRATIVE_ABLATIVE = MiscTypeFlag.F_ANTI_PENETRATIVE_ABLATIVE; + public static final MiscTypeFlag F_HEAT_DISSIPATING = MiscTypeFlag.F_HEAT_DISSIPATING; + public static final MiscTypeFlag F_IMPACT_RESISTANT = MiscTypeFlag.F_IMPACT_RESISTANT; + public static final MiscTypeFlag F_BALLISTIC_REINFORCED = MiscTypeFlag.F_BALLISTIC_REINFORCED; + public static final MiscTypeFlag F_HARJEL_II = MiscTypeFlag.F_HARJEL_II; + public static final MiscTypeFlag F_HARJEL_III = MiscTypeFlag.F_HARJEL_III; + public static final MiscTypeFlag F_RADICAL_HEATSINK = MiscTypeFlag.F_RADICAL_HEATSINK; + public static final MiscTypeFlag F_BA_MANIPULATOR = MiscTypeFlag.F_BA_MANIPULATOR; + public static final MiscTypeFlag F_NOVA = MiscTypeFlag.F_NOVA; + public static final MiscTypeFlag F_BOMB_BAY = MiscTypeFlag.F_BOMB_BAY; + public static final MiscTypeFlag F_LIGHT_FLUID_SUCTION_SYSTEM = MiscTypeFlag.F_LIGHT_FLUID_SUCTION_SYSTEM; + public static final MiscTypeFlag F_MONOCYCLE = MiscTypeFlag.F_MONOCYCLE; + public static final MiscTypeFlag F_BICYCLE = MiscTypeFlag.F_BICYCLE; + public static final MiscTypeFlag F_CONVERTIBLE = MiscTypeFlag.F_CONVERTIBLE; + public static final MiscTypeFlag F_BATTLEMEK_NIU = MiscTypeFlag.F_BATTLEMEK_NIU; + public static final MiscTypeFlag F_SNOWMOBILE = MiscTypeFlag.F_SNOWMOBILE; + public static final MiscTypeFlag F_LADDER = MiscTypeFlag.F_LADDER; + public static final MiscTypeFlag F_LIFEBOAT = MiscTypeFlag.F_LIFEBOAT; + public static final MiscTypeFlag F_FLUID_SUCTION_SYSTEM = MiscTypeFlag.F_FLUID_SUCTION_SYSTEM; + public static final MiscTypeFlag F_HYDROFOIL = MiscTypeFlag.F_HYDROFOIL; + public static final MiscTypeFlag F_SUBMERSIBLE = MiscTypeFlag.F_SUBMERSIBLE; // Flag for BattleArmor Modular Equipment Adaptor - public static final BigInteger F_BA_MEA = BigInteger.valueOf(1).shiftLeft(186); + public static final MiscTypeFlag F_BA_MEA = MiscTypeFlag.F_BA_MEA; // Flag for Infantry Equipment - public static final BigInteger F_INF_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(187); - public static final BigInteger F_SCM = BigInteger.valueOf(1).shiftLeft(188); - public static final BigInteger F_VIRAL_JAMMER_HOMING = BigInteger.valueOf(1).shiftLeft(189); - public static final BigInteger F_VIRAL_JAMMER_DECOY = BigInteger.valueOf(1).shiftLeft(190); - public static final BigInteger F_DRONE_CONTROL_CONSOLE = BigInteger.valueOf(1).shiftLeft(191); - public static final BigInteger F_RISC_LASER_PULSE_MODULE = BigInteger.valueOf(1).shiftLeft(192); - public static final BigInteger F_REMOTE_DRONE_COMMAND_CONSOLE = BigInteger.valueOf(1).shiftLeft(193); - public static final BigInteger F_EMERGENCY_COOLANT_SYSTEM = BigInteger.valueOf(1).shiftLeft(194); - public static final BigInteger F_BADC = BigInteger.valueOf(1).shiftLeft(195); - public static final BigInteger F_REUSABLE = BigInteger.valueOf(1).shiftLeft(196); - - public static final BigInteger F_BLOODHOUND = BigInteger.valueOf(1).shiftLeft(197); - public static final BigInteger F_ARMOR_KIT = BigInteger.valueOf(1).shiftLeft(198); + public static final MiscTypeFlag F_INF_EQUIPMENT = MiscTypeFlag.F_INF_EQUIPMENT; + public static final MiscTypeFlag F_SCM = MiscTypeFlag.F_SCM; + public static final MiscTypeFlag F_VIRAL_JAMMER_HOMING = MiscTypeFlag.F_VIRAL_JAMMER_HOMING; + public static final MiscTypeFlag F_VIRAL_JAMMER_DECOY = MiscTypeFlag.F_VIRAL_JAMMER_DECOY; + public static final MiscTypeFlag F_DRONE_CONTROL_CONSOLE = MiscTypeFlag.F_DRONE_CONTROL_CONSOLE; + public static final MiscTypeFlag F_RISC_LASER_PULSE_MODULE = MiscTypeFlag.F_RISC_LASER_PULSE_MODULE; + public static final MiscTypeFlag F_REMOTE_DRONE_COMMAND_CONSOLE = MiscTypeFlag.F_REMOTE_DRONE_COMMAND_CONSOLE; + public static final MiscTypeFlag F_EMERGENCY_COOLANT_SYSTEM = MiscTypeFlag.F_EMERGENCY_COOLANT_SYSTEM; + public static final MiscTypeFlag F_BADC = MiscTypeFlag.F_BADC; + public static final MiscTypeFlag F_REUSABLE = MiscTypeFlag.F_REUSABLE; + + public static final MiscTypeFlag F_BLOODHOUND = MiscTypeFlag.F_BLOODHOUND; + public static final MiscTypeFlag F_ARMOR_KIT = MiscTypeFlag.F_ARMOR_KIT; // Flags for Large Craft Systems - public static final BigInteger F_STORAGE_BATTERY = BigInteger.valueOf(1).shiftLeft(199); - public static final BigInteger F_LIGHT_SAIL = BigInteger.valueOf(1).shiftLeft(200); + public static final MiscTypeFlag F_STORAGE_BATTERY = MiscTypeFlag.F_STORAGE_BATTERY; + public static final MiscTypeFlag F_LIGHT_SAIL = MiscTypeFlag.F_LIGHT_SAIL; // Prototype Stuff - public static final BigInteger F_ARTEMIS_PROTO = BigInteger.valueOf(1).shiftLeft(201); - public static final BigInteger F_CASEP = BigInteger.valueOf(1).shiftLeft(202); - - public static final BigInteger F_VEEDC = BigInteger.valueOf(1).shiftLeft(203); - public static final BigInteger F_SC_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(204); - public static final BigInteger F_DS_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(205); - public static final BigInteger F_JS_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(206); - public static final BigInteger F_WS_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(207); - public static final BigInteger F_SS_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(208); - public static final BigInteger F_CAPITAL_ARMOR = BigInteger.valueOf(1).shiftLeft(209); - public static final BigInteger F_FERRO_CARBIDE = BigInteger.valueOf(1).shiftLeft(210); - public static final BigInteger F_IMP_FERRO = BigInteger.valueOf(1).shiftLeft(211); + public static final MiscTypeFlag F_ARTEMIS_PROTO = MiscTypeFlag.F_ARTEMIS_PROTO; + public static final MiscTypeFlag F_CASEP = MiscTypeFlag.F_CASEP; + + public static final MiscTypeFlag F_VEEDC = MiscTypeFlag.F_VEEDC; + public static final MiscTypeFlag F_SC_EQUIPMENT = MiscTypeFlag.F_SC_EQUIPMENT; + public static final MiscTypeFlag F_DS_EQUIPMENT = MiscTypeFlag.F_DS_EQUIPMENT; + public static final MiscTypeFlag F_JS_EQUIPMENT = MiscTypeFlag.F_JS_EQUIPMENT; + public static final MiscTypeFlag F_WS_EQUIPMENT = MiscTypeFlag.F_WS_EQUIPMENT; + public static final MiscTypeFlag F_SS_EQUIPMENT = MiscTypeFlag.F_SS_EQUIPMENT; + public static final MiscTypeFlag F_CAPITAL_ARMOR = MiscTypeFlag.F_CAPITAL_ARMOR; + public static final MiscTypeFlag F_FERRO_CARBIDE = MiscTypeFlag.F_FERRO_CARBIDE; + public static final MiscTypeFlag F_IMP_FERRO = MiscTypeFlag.F_IMP_FERRO; // Not usable by small support vehicles - public static final BigInteger F_HEAVY_EQUIPMENT = BigInteger.valueOf(1).shiftLeft(212); + public static final MiscTypeFlag F_HEAVY_EQUIPMENT = MiscTypeFlag.F_HEAVY_EQUIPMENT; // Drone Equipment for Large Craft - public static final BigInteger F_SRCS = BigInteger.valueOf(1).shiftLeft(213); - public static final BigInteger F_SASRCS = BigInteger.valueOf(1).shiftLeft(214); - public static final BigInteger F_CASPAR = BigInteger.valueOf(1).shiftLeft(215); - public static final BigInteger F_CASPARII = BigInteger.valueOf(1).shiftLeft(216); - public static final BigInteger F_ATAC = BigInteger.valueOf(1).shiftLeft(217); - public static final BigInteger F_DTAC = BigInteger.valueOf(1).shiftLeft(218); - public static final BigInteger F_SDS_DESTRUCT = BigInteger.valueOf(1).shiftLeft(219); - public static final BigInteger F_SDS_JAMMER = BigInteger.valueOf(1).shiftLeft(220); - public static final BigInteger F_LF_STORAGE_BATTERY = BigInteger.valueOf(1).shiftLeft(221); - public static final BigInteger F_PROTOMEK_MELEE = BigInteger.valueOf(1).shiftLeft(222); - public static final BigInteger F_EXTERNAL_POWER_PICKUP = BigInteger.valueOf(1).shiftLeft(223); - public static final BigInteger F_RAM_PLATE = BigInteger.valueOf(1).shiftLeft(224); - public static final BigInteger F_PROTOTYPE = BigInteger.valueOf(1).shiftLeft(225); + public static final MiscTypeFlag F_SRCS = MiscTypeFlag.F_SRCS; + public static final MiscTypeFlag F_SASRCS = MiscTypeFlag.F_SASRCS; + public static final MiscTypeFlag F_CASPAR = MiscTypeFlag.F_CASPAR; + public static final MiscTypeFlag F_CASPARII = MiscTypeFlag.F_CASPARII; + public static final MiscTypeFlag F_ATAC = MiscTypeFlag.F_ATAC; + public static final MiscTypeFlag F_DTAC = MiscTypeFlag.F_DTAC; + public static final MiscTypeFlag F_SDS_DESTRUCT = MiscTypeFlag.F_SDS_DESTRUCT; + public static final MiscTypeFlag F_SDS_JAMMER = MiscTypeFlag.F_SDS_JAMMER; + public static final MiscTypeFlag F_LF_STORAGE_BATTERY = MiscTypeFlag.F_LF_STORAGE_BATTERY; + public static final MiscTypeFlag F_PROTOMEK_MELEE = MiscTypeFlag.F_PROTOMEK_MELEE; + public static final MiscTypeFlag F_EXTERNAL_POWER_PICKUP = MiscTypeFlag.F_EXTERNAL_POWER_PICKUP; + public static final MiscTypeFlag F_RAM_PLATE = MiscTypeFlag.F_RAM_PLATE; + public static final MiscTypeFlag F_PROTOTYPE = MiscTypeFlag.F_PROTOTYPE; // Fortify Equipment - public static final BigInteger F_TRENCH_CAPABLE = BigInteger.valueOf(1).shiftLeft(226); - public static final BigInteger F_SUPPORT_VEE_BAR_ARMOR = BigInteger.valueOf(1).shiftLeft(227); + public static final MiscTypeFlag F_TRENCH_CAPABLE = MiscTypeFlag.F_TRENCH_CAPABLE; + public static final MiscTypeFlag F_SUPPORT_VEE_BAR_ARMOR = MiscTypeFlag.F_SUPPORT_VEE_BAR_ARMOR; // Secondary Flags for Physical Weapons public static final long S_CLUB = 1L << 0; // BMR - Indicates an Improvised Club diff --git a/megamek/src/megamek/common/MiscTypeFlag.java b/megamek/src/megamek/common/MiscTypeFlag.java new file mode 100644 index 00000000000..83bedcba442 --- /dev/null +++ b/megamek/src/megamek/common/MiscTypeFlag.java @@ -0,0 +1,287 @@ +/* + * Copyright (c) 2025 - The MegaMek Team. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ +package megamek.common; + +/** + * @author Luana Coppio + */ +public enum MiscTypeFlag implements IndexedFlag { + + // equipment flags (okay, like every type of equipment has its own flag) + F_HEAT_SINK(0), + F_DOUBLE_HEAT_SINK(1), + F_JUMP_JET(2), + F_CASE(3), + F_MASC(4), + F_TSM(5), + F_LASER_HEAT_SINK(6), + F_C3S(7), + F_C3I(8), + F_ARTEMIS(9), + F_TARGCOMP(10), + F_ANGEL_ECM(11), + F_BOARDING_CLAW(12), + F_VACUUM_PROTECTION(13), + F_MAGNET_CLAW(14), + F_FIRE_RESISTANT(15), + F_STEALTH(16), + F_MINE(17), + F_TOOLS(18), + F_MAGNETIC_CLAMP(19), + F_PARAFOIL(20), + F_FERRO_FIBROUS(21), + F_ENDO_STEEL(22), + F_AP_POD(23), + F_SEARCHLIGHT(24), + F_CLUB(25), + F_HAND_WEAPON(26), + F_COWL(27), + F_JUMP_BOOSTER(28), + F_HARJEL(29), + F_UMU(30), + F_BA_VTOL(31), + F_SPIKES(32), + F_COMMUNICATIONS(33), + F_PPC_CAPACITOR(34), + F_REFLECTIVE(35), + F_REACTIVE(36), + F_CASEII(37), + F_LIFTHOIST(38), + F_ENVIRONMENTAL_SEALING(39), + F_ARMORED_CHASSIS(40), + F_TRACTOR_MODIFICATION(41), + F_ACTUATOR_ENHANCEMENT_SYSTEM(42), + F_ECM(43), + F_BAP(44), + F_MODULAR_ARMOR(45), + F_TALON(46), + F_VISUAL_CAMO(47), + F_APOLLO(48), + F_INDUSTRIAL_TSM(49), + F_NULLSIG(50), + F_VOIDSIG(51), + F_CHAMELEON_SHIELD(52), + F_VIBROCLAW(53), + F_SINGLE_HEX_ECM(54), + F_EJECTION_SEAT(55), + F_SALVAGE_ARM(56), + F_PARTIAL_WING(57), + F_FERRO_LAMELLOR(58), + F_ARTEMIS_V(59), + // TODO: Implement me, so far only construction data + F_TRACKS(60), + // TODO: Implement me, so far only construction data + F_MASS(61), + // TODO: Implement me, so far only construction data + F_CARGO(62), + // TODO: Implement me, so far only construction data + F_DUMPER(63), + // TODO: Implement me, so far only construction data + F_MASH(64), + F_BA_EQUIPMENT(65), + F_MEK_EQUIPMENT(66), + F_TANK_EQUIPMENT(67), + F_FIGHTER_EQUIPMENT(68), + F_SUPPORT_TANK_EQUIPMENT(69), + F_PROTOMEK_EQUIPMENT(70), + + // Moved the unit types to the top of the list. + F_ARMORED_GLOVE(71), + F_BASIC_MANIPULATOR(72), + F_BATTLE_CLAW(73), + F_AP_MOUNT(74), + F_MAST_MOUNT(75), + F_FUEL(76), + F_BLUE_SHIELD(77), + F_BASIC_FIRECONTROL(78), + F_ADVANCED_FIRECONTROL(79), + F_ENDO_COMPOSITE(80), + F_LASER_INSULATOR(81), + F_LIQUID_CARGO(82), + F_WATCHDOG(83), + F_EW_EQUIPMENT(84), + F_CCM(85), + F_HITCH(86), + F_FLOTATION_HULL(87), + F_LIMITED_AMPHIBIOUS(88), + F_FULLY_AMPHIBIOUS(89), + F_DUNE_BUGGY(90), + F_SHOULDER_TURRET(91), + F_HEAD_TURRET(92), + F_QUAD_TURRET(93), + F_SPACE_ADAPTATION(94), + F_CUTTING_TORCH(95), + F_OFF_ROAD(96), + F_C3SBS(97), + F_VTOL_EQUIPMENT(98), + F_NAVAL_C3(99), + F_MINESWEEPER(100), + F_MOBILE_HPG(101), + F_FIELD_KITCHEN(102), + F_MOBILE_FIELD_BASE(103), + // TODO: add game rules for the following imagers/radars, construction data + // only + F_HIRES_IMAGER(104), + F_HYPERSPECTRAL_IMAGER(105), + F_INFRARED_IMAGER(106), + F_LOOKDOWN_RADAR(107), + + F_COMMAND_CONSOLE(108), + F_VSTOL_CHASSIS(109), + F_STOL_CHASSIS(110), + F_SPONSON_TURRET(111), + F_ARMORED_MOTIVE_SYSTEM(112), + F_CHASSIS_MODIFICATION(113), + F_CHAFF_POD(114), + F_DRONE_CARRIER_CONTROL(115), + F_VARIABLE_SIZE(116), + F_BA_MISSION_EQUIPMENT(117), + F_JET_BOOSTER(118), + F_SENSOR_DISPENSER(119), + F_DRONE_OPERATING_SYSTEM(120), + F_RECON_CAMERA(121), + F_COMBAT_VEHICLE_ESCAPE_POD(122), + F_DETACHABLE_WEAPON_PACK(123), + F_HEAT_SENSOR(124), + F_EXTENDED_LIFESUPPORT(125), + F_SPRAYER(126), + F_ELECTRIC_DISCHARGE_ARMOR(127), + F_MECHANICAL_JUMP_BOOSTER(128), + F_TRAILER_MODIFICATION(129), + F_LARGE_COMM_SCANNER_SUITE(130), + F_SMALL_COMM_SCANNER_SUITE(131), + F_LIGHT_BRIDGE_LAYER(132), + F_MEDIUM_BRIDGE_LAYER(133), + F_HEAVY_BRIDGE_LAYER(134), + F_BA_SEARCHLIGHT(135), + F_BOOBY_TRAP(136), + F_SPLITABLE(137), + F_REFUELING_DROGUE(138), + F_BULLDOZER(139), + F_EXTERNAL_STORES_HARDPOINT(140), + F_COMPACT_HEAT_SINK(141), + F_MANIPULATOR(142), + F_CARGOLIFTER(143), + F_PINTLE_TURRET(144), + F_IS_DOUBLE_HEAT_SINK_PROTOTYPE(145), + F_NAVAL_TUG_ADAPTOR(146), + F_AMPHIBIOUS(147), + F_PROP(148), + F_ULTRA_LIGHT(149), + F_SPACE_MINE_DISPENSER(150), + F_VEHICLE_MINE_DISPENSER(151), + F_LIGHT_FERRO(152), + F_HEAVY_FERRO(153), + F_FERRO_FIBROUS_PROTO(154), + F_REINFORCED(155), + F_COMPOSITE(156), + F_INDUSTRIAL_STRUCTURE(157), + F_ENDO_STEEL_PROTO(158), + F_INDUSTRIAL_ARMOR(159), + F_HEAVY_INDUSTRIAL_ARMOR(160), + F_PRIMITIVE_ARMOR(161), + F_HARDENED_ARMOR(162), + F_COMMERCIAL_ARMOR(163), + F_C3EM(164), + F_ANTI_PENETRATIVE_ABLATIVE(165), + F_HEAT_DISSIPATING(166), + F_IMPACT_RESISTANT(167), + F_BALLISTIC_REINFORCED(168), + F_HARJEL_II(169), + F_HARJEL_III(170), + F_RADICAL_HEATSINK(171), + F_BA_MANIPULATOR(172), + F_NOVA(173), + F_BOMB_BAY(174), + F_LIGHT_FLUID_SUCTION_SYSTEM(175), + F_MONOCYCLE(176), + F_BICYCLE(177), + F_CONVERTIBLE(178), + F_BATTLEMEK_NIU(179), + F_SNOWMOBILE(180), + F_LADDER(181), + F_LIFEBOAT(182), + F_FLUID_SUCTION_SYSTEM(183), + F_HYDROFOIL(184), + F_SUBMERSIBLE(185), + + // Flag for BattleArmor Modular Equipment Adaptor + F_BA_MEA(186), + + // Flag for Infantry Equipment + F_INF_EQUIPMENT(187), + F_SCM(188), + F_VIRAL_JAMMER_HOMING(189), + F_VIRAL_JAMMER_DECOY(190), + F_DRONE_CONTROL_CONSOLE(191), + F_RISC_LASER_PULSE_MODULE(192), + F_REMOTE_DRONE_COMMAND_CONSOLE(193), + F_EMERGENCY_COOLANT_SYSTEM(194), + F_BADC(195), + F_REUSABLE(196), + + F_BLOODHOUND(197), + F_ARMOR_KIT(198), + + // Flags for Large Craft Systems + F_STORAGE_BATTERY(199), + F_LIGHT_SAIL(200), + + // Prototype Stuff + F_ARTEMIS_PROTO(201), + F_CASEP(202), + + F_VEEDC(203), + F_SC_EQUIPMENT(204), + F_DS_EQUIPMENT(205), + F_JS_EQUIPMENT(206), + F_WS_EQUIPMENT(207), + F_SS_EQUIPMENT(208), + F_CAPITAL_ARMOR(209), + F_FERRO_CARBIDE(210), + F_IMP_FERRO(211), + // Not usable by small support vehicles + F_HEAVY_EQUIPMENT(212), + // Drone Equipment for Large Craft + F_SRCS(213), + F_SASRCS(214), + F_CASPAR(215), + F_CASPARII(216), + F_ATAC(217), + F_DTAC(218), + F_SDS_DESTRUCT(219), + F_SDS_JAMMER(220), + F_LF_STORAGE_BATTERY(221), + F_PROTOMEK_MELEE(222), + F_EXTERNAL_POWER_PICKUP(223), + F_RAM_PLATE(224), + F_PROTOTYPE(225), + // Fortify Equipment + F_TRENCH_CAPABLE(226), + F_SUPPORT_VEE_BAR_ARMOR(227); + + private final int flagIndex; + + MiscTypeFlag(int flagIndex) { + assert flagIndex >= 0; + this.flagIndex = flagIndex; + } + + @Override + public int getFlagIndex() { + return flagIndex; + } + + +} diff --git a/megamek/src/megamek/common/WeaponType.java b/megamek/src/megamek/common/WeaponType.java index ae5584a8059..7357b8293fa 100644 --- a/megamek/src/megamek/common/WeaponType.java +++ b/megamek/src/megamek/common/WeaponType.java @@ -14,7 +14,6 @@ */ package megamek.common; -import java.math.BigInteger; import java.util.List; import megamek.common.alphaStrike.AlphaStrikeElement; @@ -87,138 +86,139 @@ public class WeaponType extends EquipmentType { // weapon flags (note: many weapons can be identified by their ammo type) // marks any weapon affected by a targeting computer - public static final BigInteger F_DIRECT_FIRE = BigInteger.valueOf(1).shiftLeft(0); - public static final BigInteger F_FLAMER = BigInteger.valueOf(1).shiftLeft(1); + public static final WeaponTypeFlag F_DIRECT_FIRE = WeaponTypeFlag.F_DIRECT_FIRE; + + public static final WeaponTypeFlag F_FLAMER = WeaponTypeFlag.F_FLAMER; // Glaze armor - public static final BigInteger F_LASER = BigInteger.valueOf(1).shiftLeft(2); - public static final BigInteger F_PPC = BigInteger.valueOf(1).shiftLeft(3); + public static final WeaponTypeFlag F_LASER = WeaponTypeFlag.F_LASER; + public static final WeaponTypeFlag F_PPC = WeaponTypeFlag.F_PPC; // for weapons that target Automatically (AMS) - public static final BigInteger F_AUTO_TARGET = BigInteger.valueOf(1).shiftLeft(4); + public static final WeaponTypeFlag F_AUTO_TARGET = WeaponTypeFlag.F_AUTO_TARGET; // can not start fires - public static final BigInteger F_NO_FIRES = BigInteger.valueOf(1).shiftLeft(5); + public static final WeaponTypeFlag F_NO_FIRES = WeaponTypeFlag.F_NO_FIRES; // must be only weapon attacking - public static final BigInteger F_SOLO_ATTACK = BigInteger.valueOf(1).shiftLeft(7); - public static final BigInteger F_VGL = BigInteger.valueOf(1).shiftLeft(8); + public static final WeaponTypeFlag F_SOLO_ATTACK = WeaponTypeFlag.F_SOLO_ATTACK; + public static final WeaponTypeFlag F_VGL = WeaponTypeFlag.F_VGL; // MGL for rapid fire setup - public static final BigInteger F_MG = BigInteger.valueOf(1).shiftLeft(9); + public static final WeaponTypeFlag F_MG = WeaponTypeFlag.F_MG; // Inferno weapon - public static final BigInteger F_INFERNO = BigInteger.valueOf(1).shiftLeft(10); + public static final WeaponTypeFlag F_INFERNO = WeaponTypeFlag.F_INFERNO; // Infantry caliber weapon, damage based on # of men shooting - public static final BigInteger F_INFANTRY = BigInteger.valueOf(1).shiftLeft(11); + public static final WeaponTypeFlag F_INFANTRY = WeaponTypeFlag.F_INFANTRY; // use missile rules for # of hits - public static final BigInteger F_MISSILE_HITS = BigInteger.valueOf(1).shiftLeft(13); - public static final BigInteger F_ONESHOT = BigInteger.valueOf(1).shiftLeft(14); - public static final BigInteger F_ARTILLERY = BigInteger.valueOf(1).shiftLeft(15); + public static final WeaponTypeFlag F_MISSILE_HITS = WeaponTypeFlag.F_MISSILE_HITS; + public static final WeaponTypeFlag F_ONESHOT = WeaponTypeFlag.F_ONESHOT; + public static final WeaponTypeFlag F_ARTILLERY = WeaponTypeFlag.F_ARTILLERY; // for Gunnery/Ballistic - public static final BigInteger F_BALLISTIC = BigInteger.valueOf(1).shiftLeft(16); + public static final WeaponTypeFlag F_BALLISTIC = WeaponTypeFlag.F_BALLISTIC; // for Gunnery/Energy - public static final BigInteger F_ENERGY = BigInteger.valueOf(1).shiftLeft(17); + public static final WeaponTypeFlag F_ENERGY = WeaponTypeFlag.F_ENERGY; // for Gunnery/Missile - public static final BigInteger F_MISSILE = BigInteger.valueOf(1).shiftLeft(18); + public static final WeaponTypeFlag F_MISSILE = WeaponTypeFlag.F_MISSILE; // fires - public static final BigInteger F_PLASMA = BigInteger.valueOf(1).shiftLeft(19); - public static final BigInteger F_INCENDIARY_NEEDLES = BigInteger.valueOf(1).shiftLeft(20); + public static final WeaponTypeFlag F_PLASMA = WeaponTypeFlag.F_PLASMA; + public static final WeaponTypeFlag F_INCENDIARY_NEEDLES = WeaponTypeFlag.F_INCENDIARY_NEEDLES; // War of 3039 prototypes - public static final BigInteger F_PROTOTYPE = BigInteger.valueOf(1).shiftLeft(21); + public static final WeaponTypeFlag F_PROTOTYPE = WeaponTypeFlag.F_PROTOTYPE; // Variable heat, heat is listed in dice, not points - public static final BigInteger F_HEATASDICE = BigInteger.valueOf(1).shiftLeft(22); + public static final WeaponTypeFlag F_HEATASDICE = WeaponTypeFlag.F_HEATASDICE; // AMS - public static final BigInteger F_AMS = BigInteger.valueOf(1).shiftLeft(23); + public static final WeaponTypeFlag F_AMS = WeaponTypeFlag.F_AMS; // may only target Infantry - public static final BigInteger F_INFANTRY_ONLY = BigInteger.valueOf(1).shiftLeft(25); + public static final WeaponTypeFlag F_INFANTRY_ONLY = WeaponTypeFlag.F_INFANTRY_ONLY; - public static final BigInteger F_TAG = BigInteger.valueOf(1).shiftLeft(26); + public static final WeaponTypeFlag F_TAG = WeaponTypeFlag.F_TAG; // C3 Master with Target Acquisition gear - public static final BigInteger F_C3M = BigInteger.valueOf(1).shiftLeft(27); + public static final WeaponTypeFlag F_C3M = WeaponTypeFlag.F_C3M; // Plasma Rifle - public static final BigInteger F_PLASMA_MFUK = BigInteger.valueOf(1).shiftLeft(28); + public static final WeaponTypeFlag F_PLASMA_MFUK = WeaponTypeFlag.F_PLASMA_MFUK; // fire Extinguisher - public static final BigInteger F_EXTINGUISHER = BigInteger.valueOf(1).shiftLeft(29); - public static final BigInteger F_PULSE = BigInteger.valueOf(1).shiftLeft(30); + public static final WeaponTypeFlag F_EXTINGUISHER = WeaponTypeFlag.F_EXTINGUISHER; + public static final WeaponTypeFlag F_PULSE = WeaponTypeFlag.F_PULSE; // Full Damage vs. Infantry - public static final BigInteger F_BURST_FIRE = BigInteger.valueOf(1).shiftLeft(31); + public static final WeaponTypeFlag F_BURST_FIRE = WeaponTypeFlag.F_BURST_FIRE; // Machine Gun Array - public static final BigInteger F_MGA = BigInteger.valueOf(1).shiftLeft(32); - public static final BigInteger F_NO_AIM = BigInteger.valueOf(1).shiftLeft(33); - public static final BigInteger F_BOMBAST_LASER = BigInteger.valueOf(1).shiftLeft(34); - public static final BigInteger F_CRUISE_MISSILE = BigInteger.valueOf(1).shiftLeft(35); - public static final BigInteger F_B_POD = BigInteger.valueOf(1).shiftLeft(36); - public static final BigInteger F_TASER = BigInteger.valueOf(1).shiftLeft(37); + public static final WeaponTypeFlag F_MGA = WeaponTypeFlag.F_MGA; + public static final WeaponTypeFlag F_NO_AIM = WeaponTypeFlag.F_NO_AIM; + public static final WeaponTypeFlag F_BOMBAST_LASER = WeaponTypeFlag.F_BOMBAST_LASER; + public static final WeaponTypeFlag F_CRUISE_MISSILE = WeaponTypeFlag.F_CRUISE_MISSILE; + public static final WeaponTypeFlag F_B_POD = WeaponTypeFlag.F_B_POD; + public static final WeaponTypeFlag F_TASER = WeaponTypeFlag.F_TASER; // Anti-ship missiles - public static final BigInteger F_ANTI_SHIP = BigInteger.valueOf(1).shiftLeft(38); - public static final BigInteger F_SPACE_BOMB = BigInteger.valueOf(1).shiftLeft(39); - public static final BigInteger F_M_POD = BigInteger.valueOf(1).shiftLeft(40); - public static final BigInteger F_DIVE_BOMB = BigInteger.valueOf(1).shiftLeft(41); - public static final BigInteger F_ALT_BOMB = BigInteger.valueOf(1).shiftLeft(42); + public static final WeaponTypeFlag F_ANTI_SHIP = WeaponTypeFlag.F_ANTI_SHIP; + public static final WeaponTypeFlag F_SPACE_BOMB = WeaponTypeFlag.F_SPACE_BOMB; + public static final WeaponTypeFlag F_M_POD = WeaponTypeFlag.F_M_POD; + public static final WeaponTypeFlag F_DIVE_BOMB = WeaponTypeFlag.F_DIVE_BOMB; + public static final WeaponTypeFlag F_ALT_BOMB = WeaponTypeFlag.F_ALT_BOMB; // Currently only used by MML - public static final BigInteger F_BA_WEAPON = BigInteger.valueOf(1).shiftLeft(43); - public static final BigInteger F_MEK_WEAPON = BigInteger.valueOf(1).shiftLeft(44); - public static final BigInteger F_AERO_WEAPON = BigInteger.valueOf(1).shiftLeft(45); - public static final BigInteger F_PROTO_WEAPON = BigInteger.valueOf(1).shiftLeft(46); - public static final BigInteger F_TANK_WEAPON = BigInteger.valueOf(1).shiftLeft(47); - - public static final BigInteger F_INFANTRY_ATTACK = BigInteger.valueOf(1).shiftLeft(48); - public static final BigInteger F_INF_BURST = BigInteger.valueOf(1).shiftLeft(49); - public static final BigInteger F_INF_AA = BigInteger.valueOf(1).shiftLeft(50); - public static final BigInteger F_INF_NONPENETRATING = BigInteger.valueOf(1).shiftLeft(51); - public static final BigInteger F_INF_POINT_BLANK = BigInteger.valueOf(1).shiftLeft(52); - public static final BigInteger F_INF_SUPPORT = BigInteger.valueOf(1).shiftLeft(53); - public static final BigInteger F_INF_ENCUMBER = BigInteger.valueOf(1).shiftLeft(54); - public static final BigInteger F_INF_ARCHAIC = BigInteger.valueOf(1).shiftLeft(55); + public static final WeaponTypeFlag F_BA_WEAPON = WeaponTypeFlag.F_BA_WEAPON; + public static final WeaponTypeFlag F_MEK_WEAPON = WeaponTypeFlag.F_MEK_WEAPON; + public static final WeaponTypeFlag F_AERO_WEAPON = WeaponTypeFlag.F_AERO_WEAPON; + public static final WeaponTypeFlag F_PROTO_WEAPON = WeaponTypeFlag.F_PROTO_WEAPON; + public static final WeaponTypeFlag F_TANK_WEAPON = WeaponTypeFlag.F_TANK_WEAPON; + + public static final WeaponTypeFlag F_INFANTRY_ATTACK = WeaponTypeFlag.F_INFANTRY_ATTACK; + public static final WeaponTypeFlag F_INF_BURST = WeaponTypeFlag.F_INF_BURST; + public static final WeaponTypeFlag F_INF_AA = WeaponTypeFlag.F_INF_AA; + public static final WeaponTypeFlag F_INF_NONPENETRATING = WeaponTypeFlag.F_INF_NONPENETRATING; + public static final WeaponTypeFlag F_INF_POINT_BLANK = WeaponTypeFlag.F_INF_POINT_BLANK; + public static final WeaponTypeFlag F_INF_SUPPORT = WeaponTypeFlag.F_INF_SUPPORT; + public static final WeaponTypeFlag F_INF_ENCUMBER = WeaponTypeFlag.F_INF_ENCUMBER; + public static final WeaponTypeFlag F_INF_ARCHAIC = WeaponTypeFlag.F_INF_ARCHAIC; // TODO Add game rules IO pg 84 - public static final BigInteger F_INF_CLIMBINGCLAWS = BigInteger.valueOf(1).shiftLeft(63); + public static final WeaponTypeFlag F_INF_CLIMBINGCLAWS = WeaponTypeFlag.F_INF_CLIMBINGCLAWS; // C3 Master Booster System - public static final BigInteger F_C3MBS = BigInteger.valueOf(1).shiftLeft(56); + public static final WeaponTypeFlag F_C3MBS = WeaponTypeFlag.F_C3MBS; // Naval Mass Drivers - public static final BigInteger F_MASS_DRIVER = BigInteger.valueOf(1).shiftLeft(58); + public static final WeaponTypeFlag F_MASS_DRIVER = WeaponTypeFlag.F_MASS_DRIVER; - public static final BigInteger F_CWS = BigInteger.valueOf(1).shiftLeft(59); + public static final WeaponTypeFlag F_CWS = WeaponTypeFlag.F_CWS; - public static final BigInteger F_MEK_MORTAR = BigInteger.valueOf(1).shiftLeft(60); + public static final WeaponTypeFlag F_MEK_MORTAR = WeaponTypeFlag.F_MEK_MORTAR; // Weapon required to make a bomb type function - public static final BigInteger F_BOMB_WEAPON = BigInteger.valueOf(1).shiftLeft(61); + public static final WeaponTypeFlag F_BOMB_WEAPON = WeaponTypeFlag.F_BOMB_WEAPON; - public static final BigInteger F_BA_INDIVIDUAL = BigInteger.valueOf(1).shiftLeft(62); + public static final WeaponTypeFlag F_BA_INDIVIDUAL = WeaponTypeFlag.F_BA_INDIVIDUAL; // Next one's out of order. See F_INF_CLIMBINGCLAWS // AMS and Point Defense Bays - Have to work differently from code using the // F_AMS flag - public static final BigInteger F_PDBAY = BigInteger.valueOf(1).shiftLeft(64); - public static final BigInteger F_AMSBAY = BigInteger.valueOf(1).shiftLeft(65); + public static final WeaponTypeFlag F_PDBAY = WeaponTypeFlag.F_PDBAY; + public static final WeaponTypeFlag F_AMSBAY = WeaponTypeFlag.F_AMSBAY; // Thunderbolt and similar large missiles, for use with AMS resolution - public static final BigInteger F_LARGEMISSILE = BigInteger.valueOf(1).shiftLeft(66); + public static final WeaponTypeFlag F_LARGEMISSILE = WeaponTypeFlag.F_LARGEMISSILE; // Hyper-Laser - public static final BigInteger F_HYPER = BigInteger.valueOf(1).shiftLeft(67); + public static final WeaponTypeFlag F_HYPER = WeaponTypeFlag.F_HYPER; // Fusillade works like a one-shot weapon but has a second round. - public static final BigInteger F_DOUBLE_ONESHOT = BigInteger.valueOf(1).shiftLeft(68); + public static final WeaponTypeFlag F_DOUBLE_ONESHOT = WeaponTypeFlag.F_DOUBLE_ONESHOT; // ER flamers do half damage in heat mode - public static final BigInteger F_ER_FLAMER = BigInteger.valueOf(1).shiftLeft(69); + public static final WeaponTypeFlag F_ER_FLAMER = WeaponTypeFlag.F_ER_FLAMER; /** Missile weapon that can be linked to an Artemis fire control system */ - public static final BigInteger F_ARTEMIS_COMPATIBLE = BigInteger.valueOf(1).shiftLeft(70); + public static final WeaponTypeFlag F_ARTEMIS_COMPATIBLE = WeaponTypeFlag.F_ARTEMIS_COMPATIBLE; /** * This flag is used by mortar-type weapons that allow indirect fire without a * spotter and/or with LOS. */ - public static final BigInteger F_MORTARTYPE_INDIRECT = BigInteger.valueOf(1).shiftLeft(71); + public static final WeaponTypeFlag F_MORTARTYPE_INDIRECT = WeaponTypeFlag.F_MORTARTYPE_INDIRECT; // Used for TSEMP Weapons. - public static final BigInteger F_TSEMP = BigInteger.valueOf(1).shiftLeft(57); - public static final BigInteger F_REPEATING = BigInteger.valueOf(1).shiftLeft(72); + public static final WeaponTypeFlag F_TSEMP = WeaponTypeFlag.F_TSEMP; + public static final WeaponTypeFlag F_REPEATING = WeaponTypeFlag.F_REPEATING; // add maximum range for AT2 public static final int RANGE_SHORT = RangeType.RANGE_SHORT; diff --git a/megamek/src/megamek/common/WeaponTypeFlag.java b/megamek/src/megamek/common/WeaponTypeFlag.java new file mode 100644 index 00000000000..a176b33c936 --- /dev/null +++ b/megamek/src/megamek/common/WeaponTypeFlag.java @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2025 - The MegaMek Team. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ +package megamek.common; + + +/** + * @author Luana Coppio + */ +public enum WeaponTypeFlag implements IndexedFlag { + // weapon flags (note: many weapons can be identified by their ammo type) + // marks any weapon affected by a targeting computer + F_DIRECT_FIRE(0), + F_FLAMER(1), + // Glaze armor + F_LASER(2), + F_PPC(3), + // for weapons that target Automatically (AMS) + F_AUTO_TARGET(4), + // can not start fires + F_NO_FIRES(5), + // must be only weapon attacking + F_SOLO_ATTACK(7), + F_VGL(8), + // MGL for rapid fire setup + F_MG(9), + // Inferno weapon + F_INFERNO(10), + // Infantry caliber weapon, damage based on # of men shooting + F_INFANTRY(11), + // use missile rules for # of hits + F_MISSILE_HITS(13), + F_ONESHOT(14), + F_ARTILLERY(15), + + // for Gunnery/Ballistic + F_BALLISTIC(16), + // for Gunnery/Energy + F_ENERGY(17), + // for Gunnery/Missile + F_MISSILE(18), + + // fires + F_PLASMA(19), + F_INCENDIARY_NEEDLES(20), + + // War of 3039 prototypes + F_PROTOTYPE(21), + // Variable heat, heat is listed in dice, not points + F_HEATASDICE(22), + // AMS + F_AMS(23), + + // may only target Infantry + F_INFANTRY_ONLY(25), + + F_TAG(26), + // C3 Master with Target Acquisition gear + F_C3M(27), + + // Plasma Rifle + F_PLASMA_MFUK(28), + // fire Extinguisher + F_EXTINGUISHER(29), + F_PULSE(30), + // Full Damage vs. Infantry + F_BURST_FIRE(31), + // Machine Gun Array + F_MGA(32), + F_NO_AIM(33), + F_BOMBAST_LASER(34), + F_CRUISE_MISSILE(35), + F_B_POD(36), + F_TASER(37), + + // Anti-ship missiles + F_ANTI_SHIP(38), + F_SPACE_BOMB(39), + F_M_POD(40), + F_DIVE_BOMB(41), + F_ALT_BOMB(42), + + // Currently only used by MML + F_BA_WEAPON(43), + F_MEK_WEAPON(44), + F_AERO_WEAPON(45), + F_PROTO_WEAPON(46), + F_TANK_WEAPON(47), + + F_INFANTRY_ATTACK(48), + F_INF_BURST(49), + F_INF_AA(50), + F_INF_NONPENETRATING(51), + F_INF_POINT_BLANK(52), + F_INF_SUPPORT(53), + F_INF_ENCUMBER(54), + F_INF_ARCHAIC(55), + + // TODO Add game rules IO pg 84 + F_INF_CLIMBINGCLAWS(63), + + // C3 Master Booster System + F_C3MBS(56), + + // Naval Mass Drivers + F_MASS_DRIVER(58), + + F_CWS(59), + + F_MEK_MORTAR(60), + + // Weapon required to make a bomb type function + F_BOMB_WEAPON(61), + + F_BA_INDIVIDUAL(62), + // Next one's out of order. See F_INF_CLIMBINGCLAWS + + // AMS and Point Defense Bays - Have to work differently from code using the + // F_AMS flag + F_PDBAY(64), + F_AMSBAY(65), + + // Thunderbolt and similar large missiles, for use with AMS resolution + F_LARGEMISSILE(66), + + // Hyper-Laser + F_HYPER(67), + + // Fusillade works like a one-shot weapon but has a second round. + F_DOUBLE_ONESHOT(68), + // ER flamers do half damage in heat mode + F_ER_FLAMER(69), + /** Missile weapon that can be linked to an Artemis fire control system */ + F_ARTEMIS_COMPATIBLE(70), + + /** + * This flag is used by mortar-type weapons that allow indirect fire without a + * spotter and/or with LOS. + */ + F_MORTARTYPE_INDIRECT(71), + + // Used for TSEMP Weapons. + F_TSEMP(57), + F_REPEATING(72); + + private final int flagIndex; + + WeaponTypeFlag(int flagIndex) { + assert flagIndex >= 0; + this.flagIndex = flagIndex; + } + + @Override + public int getFlagIndex() { + return flagIndex; + } + +} diff --git a/megamek/src/megamek/common/pathfinder/CachedEntityState.java b/megamek/src/megamek/common/pathfinder/CachedEntityState.java index 34772be8dc4..c7e9d517516 100644 --- a/megamek/src/megamek/common/pathfinder/CachedEntityState.java +++ b/megamek/src/megamek/common/pathfinder/CachedEntityState.java @@ -18,16 +18,10 @@ */ package megamek.common.pathfinder; -import java.math.BigInteger; import java.util.HashMap; import java.util.Map; -import megamek.common.Entity; -import megamek.common.MPCalculationSetting; -import megamek.common.Mek; -import megamek.common.MiscType; -import megamek.common.QuadMek; -import megamek.common.TripodMek; +import megamek.common.*; /** * A transient class used to lazy-load "calculated" information from an entity @@ -46,7 +40,7 @@ public class CachedEntityState { private Integer sprintMPWithoutMasc; private Integer jumpMP; private Integer jumpMPWithTerrain; - private Map hasWorkingMisc; + private Map hasWorkingMisc; private Integer torsoJumpJets; private Integer jumpMPNoGravity; private Integer numBreachedLegs; @@ -128,7 +122,7 @@ public int getJumpMPWithTerrain() { return jumpMPWithTerrain; } - public boolean hasWorkingMisc(BigInteger flag) { + public boolean hasWorkingMisc(IndexedFlag flag) { if (!hasWorkingMisc.containsKey(flag)) { hasWorkingMisc.put(flag, backingEntity.hasWorkingMisc(flag)); } diff --git a/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java b/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java index ebfb0b54f4a..40b8cc7867e 100644 --- a/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java +++ b/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java @@ -23,7 +23,6 @@ import megamek.common.weapons.bayweapons.BayWeapon; import megamek.common.weapons.capitalweapons.ScreenLauncherWeapon; -import java.math.BigInteger; import java.util.*; import java.util.stream.Collectors; @@ -711,7 +710,7 @@ public boolean hasIllegalEquipmentCombinations(StringBuffer buff) { Map rightBroad = new HashMap<>(); Map massDriversPerArc = new HashMap<>(); - BigInteger typeFlag = MiscType.F_JS_EQUIPMENT; + var typeFlag = MiscType.F_JS_EQUIPMENT; if (vessel.hasETypeFlag(Entity.ETYPE_WARSHIP)) { typeFlag = MiscType.F_WS_EQUIPMENT; } else if (vessel.hasETypeFlag(Entity.ETYPE_SPACE_STATION)) { diff --git a/megamek/src/megamek/common/verifier/TestSmallCraft.java b/megamek/src/megamek/common/verifier/TestSmallCraft.java index 084ff1f2d0c..3f66622f35a 100644 --- a/megamek/src/megamek/common/verifier/TestSmallCraft.java +++ b/megamek/src/megamek/common/verifier/TestSmallCraft.java @@ -14,7 +14,6 @@ */ package megamek.common.verifier; -import java.math.BigInteger; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -585,7 +584,7 @@ public boolean hasIllegalEquipmentCombinations(StringBuffer buff) { Map leftAft = new HashMap<>(); Map rightFwd = new HashMap<>(); Map rightAft = new HashMap<>(); - BigInteger typeFlag = smallCraft.hasETypeFlag(Entity.ETYPE_DROPSHIP) + var typeFlag = smallCraft.hasETypeFlag(Entity.ETYPE_DROPSHIP) ? MiscType.F_DS_EQUIPMENT : MiscType.F_SC_EQUIPMENT; for (Mounted m : smallCraft.getEquipment()) { diff --git a/megamek/src/megamek/common/verifier/TestSupportVehicle.java b/megamek/src/megamek/common/verifier/TestSupportVehicle.java index d4d81b3f0fb..3168802bc85 100644 --- a/megamek/src/megamek/common/verifier/TestSupportVehicle.java +++ b/megamek/src/megamek/common/verifier/TestSupportVehicle.java @@ -20,7 +20,6 @@ */ package megamek.common.verifier; -import java.math.BigInteger; import java.util.ArrayList; import java.util.EnumSet; import java.util.HashSet; @@ -887,13 +886,14 @@ public double getWeightPowerAmp() { return 0.0; } + private static final EquipmentBitSet EXCLUDE = MiscType.F_BASIC_FIRECONTROL.asEquipmentBitSet().or(MiscType.F_ADVANCED_FIRECONTROL) + .or(MiscType.F_CHASSIS_MODIFICATION); + @Override protected boolean includeMiscEquip(MiscType eq) { // fire control is counted with control system weight and chassis mods are part // of the structure weight - final BigInteger exclude = MiscType.F_BASIC_FIRECONTROL.or(MiscType.F_ADVANCED_FIRECONTROL) - .or(MiscType.F_CHASSIS_MODIFICATION); - return !eq.hasFlag(exclude); + return !eq.hasFlag(EXCLUDE); } @Override diff --git a/megamek/src/megamek/common/weapons/bayweapons/CapitalMDBayWeapon.java b/megamek/src/megamek/common/weapons/bayweapons/CapitalMDBayWeapon.java index 90f70a33b1e..7bc626dba14 100644 --- a/megamek/src/megamek/common/weapons/bayweapons/CapitalMDBayWeapon.java +++ b/megamek/src/megamek/common/weapons/bayweapons/CapitalMDBayWeapon.java @@ -37,9 +37,9 @@ public CapitalMDBayWeapon() { this.cost = 0; this.atClass = CLASS_CAPITAL_MD; this.capital = true; - this.flags = F_MASS_DRIVER; + this.flags = F_MASS_DRIVER.asEquipmentBitSet(); } - + @Override public int getBattleForceClass() { return BFCLASS_CAPITAL; diff --git a/megamek/src/megamek/common/weapons/other/CLLaserAMS.java b/megamek/src/megamek/common/weapons/other/CLLaserAMS.java index 5e3f543ffec..bd3ccd66924 100644 --- a/megamek/src/megamek/common/weapons/other/CLLaserAMS.java +++ b/megamek/src/megamek/common/weapons/other/CLLaserAMS.java @@ -50,7 +50,7 @@ public CLLaserAMS() { // we need to remove the direct fire flag again, so TC weight is not affected flags = flags.or(F_MEK_WEAPON).or(F_TANK_WEAPON).or(F_AERO_WEAPON) .andNot(F_PROTO_WEAPON).or(F_AUTO_TARGET).or(F_AMS).or(F_ENERGY) - .and(F_DIRECT_FIRE.not()); + .andNot(F_DIRECT_FIRE); setModes(new String[] { "On", "Off" }); setInstantModeSwitch(false); cost = 225000; diff --git a/megamek/src/megamek/common/weapons/other/ISLaserAMS.java b/megamek/src/megamek/common/weapons/other/ISLaserAMS.java index 26a1aeed976..aebd25fe79c 100644 --- a/megamek/src/megamek/common/weapons/other/ISLaserAMS.java +++ b/megamek/src/megamek/common/weapons/other/ISLaserAMS.java @@ -51,7 +51,7 @@ public ISLaserAMS() { // we need to remove the direct fire flag again, so TC weight is not // affected flags = flags.or(F_MEK_WEAPON).or(F_TANK_WEAPON).or(F_AERO_WEAPON).andNot(F_PROTO_WEAPON) - .or(F_AUTO_TARGET).or(F_AMS).or(F_ENERGY).and(F_DIRECT_FIRE.not()); + .or(F_AUTO_TARGET).or(F_AMS).or(F_ENERGY).andNot(F_DIRECT_FIRE); setModes(new String[] { "On", "Off" }); setInstantModeSwitch(false); cost = 225000; diff --git a/megamek/src/megamek/common/weapons/unofficial/ISLaserAMSTHB.java b/megamek/src/megamek/common/weapons/unofficial/ISLaserAMSTHB.java index 83d4e9fb5b3..d7580f5e31f 100644 --- a/megamek/src/megamek/common/weapons/unofficial/ISLaserAMSTHB.java +++ b/megamek/src/megamek/common/weapons/unofficial/ISLaserAMSTHB.java @@ -48,7 +48,7 @@ public ISLaserAMSTHB() { // affected flags = flags.or(F_MEK_WEAPON).or(F_TANK_WEAPON).or(F_AERO_WEAPON).andNot(F_PROTO_WEAPON) .or(F_AUTO_TARGET).or(F_HEATASDICE).or(F_AMS).or(F_ENERGY) - .and(F_DIRECT_FIRE.not()); + .andNot(F_DIRECT_FIRE); setModes(new String[] { "On", "Off" }); setInstantModeSwitch(false); cost = 300000; diff --git a/megamek/unittests/megamek/client/bot/princess/FireControlTest.java b/megamek/unittests/megamek/client/bot/princess/FireControlTest.java index c3c5e070cdb..79f0079ef72 100644 --- a/megamek/unittests/megamek/client/bot/princess/FireControlTest.java +++ b/megamek/unittests/megamek/client/bot/princess/FireControlTest.java @@ -40,7 +40,6 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; import java.util.EnumSet; @@ -429,7 +428,7 @@ void beforeEach() { when(mockAmmoSRM5.getType()).thenReturn(mockAmmoTypeSRM5); when(mockAmmoSRM5.isAmmoUsable()).thenReturn(true); when(mockAmmoTypeLRM5.getMunitionType()).thenReturn(EnumSet.of(AmmoType.Munitions.M_STANDARD)); - when(mockAmmoTypeLRM5.hasFlag(any(BigInteger.class))).thenReturn(false); + when(mockAmmoTypeLRM5.hasFlag(any(IndexedFlag.class))).thenReturn(false); when(mockAmmoTypeLRM5.hasFlag(eq(AmmoType.F_MML_LRM))).thenReturn(true); when(mockAmmoTypeLRM5.getAmmoType()).thenReturn(AmmoType.T_MML); when(mockAmmoLRM5.getType()).thenReturn(mockAmmoTypeLRM5); @@ -521,7 +520,7 @@ void beforeEach() { when(mockWeaponType.getAmmoType()).thenReturn(AmmoType.T_LRM); WeaponType mockEnergyWeaponType = mock(WeaponType.class); when(mockEnergyWeaponType.getAmmoType()).thenReturn(AmmoType.T_NA); - when(mockEnergyWeaponType.hasFlag(any())).thenReturn(false); + when(mockEnergyWeaponType.hasFlag(any(IndexedFlag.class))).thenReturn(false); when(mockEnergyWeaponType.hasModeType(anyString())).thenReturn(false); mockPPC = mock(WeaponMounted.class); when(mockPPC.getType()).thenReturn(mockEnergyWeaponType); @@ -2151,7 +2150,7 @@ void testGuessFullAirToGroundPlan() { FiringPlan expected; when(mockShooter.getPosition()).thenReturn(mockShooterCoords); when(mockShooter.isOffBoard()).thenReturn(false); - when(mockShooter.getBombs(any(BigInteger.class))).thenReturn(emptyList()); + when(mockShooter.getBombs(any(IndexedFlag.class))).thenReturn(emptyList()); when(mockTarget.getPosition()).thenReturn(mockTargetCoords); when(mockTarget.isOffBoard()).thenReturn(false); when(mockBoard.contains(eq(mockShooterCoords))).thenReturn(true); From 7a46414a13fe7d7f369e129f9c32e1511a7b2e1a Mon Sep 17 00:00:00 2001 From: Scoppio Date: Fri, 31 Jan 2025 18:31:35 -0300 Subject: [PATCH 2/4] chore: better doc and some changes to comments --- megamek/src/megamek/common/AmmoTypeFlag.java | 41 ++--- megamek/src/megamek/common/MiscTypeFlag.java | 60 +++---- megamek/src/megamek/common/WeaponType.java | 1 - .../src/megamek/common/WeaponTypeFlag.java | 147 +++++------------- 4 files changed, 75 insertions(+), 174 deletions(-) diff --git a/megamek/src/megamek/common/AmmoTypeFlag.java b/megamek/src/megamek/common/AmmoTypeFlag.java index 309024eeccc..0214b4fcbd8 100644 --- a/megamek/src/megamek/common/AmmoTypeFlag.java +++ b/megamek/src/megamek/common/AmmoTypeFlag.java @@ -14,47 +14,32 @@ package megamek.common; /** + * Set of flags that can be used to determine how the ammo is used and its + * special properties * @author Luana Coppio */ public enum AmmoTypeFlag implements IndexedFlag { - - // ammo flags - F_MG(0), + F_MG(0), // Machinegun ammo F_BATTLEARMOR(1), // only used by BA squads F_PROTOMEK(2), // only used by ProtoMeks F_HOTLOAD(3), // Ammo can be hotloaded - - // BA can't jump or make anti-mek until dumped - F_ENCUMBERING(4), - - F_MML_LRM(5), // LRM type + F_ENCUMBERING(4), // Encumbering ammo - if loaded on a BA it cant jump or make anti-mek attacks until dumped F_AR10_WHITE_SHARK(6), // White shark type F_AR10_KILLER_WHALE(7), // Killer Whale type F_AR10_BARRACUDA(8), // barracuda type F_NUCLEAR(9), // Nuclear missile - F_SANTA_ANNA(14), // Santa Anna Missile - F_PEACEMAKER(15), // Peacemaker Missile + F_SANTA_ANNA(14), // Nuke Santa Anna Missile + F_PEACEMAKER(15), // Nuke Peacemaker Missile F_TELE_MISSILE(10), // Tele-Missile F_CAP_MISSILE(11), // Other Capital-Missile - F_SPACE_BOMB(12), // can be used to space bomb - - // can be used to ground bomb - F_GROUND_BOMB(13), + F_SPACE_BOMB(12), // defines that the ammo can be used to space bomb + F_GROUND_BOMB(13), // the ammo can be used to ground bomb + F_MML_LRM(5), // LRM type F_MML_SRM(14), // SRM type - - // Numbers 14-15 out of order. See nuclear missiles, above - - // For tag, rl pods, missiles and the like - F_OTHER_BOMB(16), - - // Used by MHQ for loading ammo bins - F_CRUISE_MISSILE(17), - - // Used by MHQ for loading ammo bins - F_SCREEN(18), - - // Used for Internal Bomb Bay bombs; to differentiate them from - F_INTERNAL_BOMB(19); + F_OTHER_BOMB(16), // For tag, rl pods, missiles and the like + F_CRUISE_MISSILE(17), // Used by MHQ for loading ammo bins + F_SCREEN(18), // Used by MHQ for loading ammo bins + F_INTERNAL_BOMB(19); // Used for Internal Bomb Bay bombs; to differentiate them from other bombs private final int flagIndex; diff --git a/megamek/src/megamek/common/MiscTypeFlag.java b/megamek/src/megamek/common/MiscTypeFlag.java index 83bedcba442..95e17397fe3 100644 --- a/megamek/src/megamek/common/MiscTypeFlag.java +++ b/megamek/src/megamek/common/MiscTypeFlag.java @@ -14,11 +14,12 @@ package megamek.common; /** + * Set of flags that can be used to determine special equipment properties + * and behaviors. + * Every type of equipment has its own flag. * @author Luana Coppio */ public enum MiscTypeFlag implements IndexedFlag { - - // equipment flags (okay, like every type of equipment has its own flag) F_HEAT_SINK(0), F_DOUBLE_HEAT_SINK(1), F_JUMP_JET(2), @@ -79,24 +80,17 @@ public enum MiscTypeFlag implements IndexedFlag { F_PARTIAL_WING(57), F_FERRO_LAMELLOR(58), F_ARTEMIS_V(59), - // TODO: Implement me, so far only construction data - F_TRACKS(60), - // TODO: Implement me, so far only construction data - F_MASS(61), - // TODO: Implement me, so far only construction data - F_CARGO(62), - // TODO: Implement me, so far only construction data - F_DUMPER(63), - // TODO: Implement me, so far only construction data - F_MASH(64), + F_TRACKS(60), // TODO: Implement me, so far only construction data + F_MASS(61), // TODO: Implement me, so far only construction data + F_CARGO(62), // TODO: Implement me, so far only construction data + F_DUMPER(63), // TODO: Implement me, so far only construction data + F_MASH(64), // TODO: Implement me, so far only construction data F_BA_EQUIPMENT(65), F_MEK_EQUIPMENT(66), F_TANK_EQUIPMENT(67), F_FIGHTER_EQUIPMENT(68), F_SUPPORT_TANK_EQUIPMENT(69), F_PROTOMEK_EQUIPMENT(70), - - // Moved the unit types to the top of the list. F_ARMORED_GLOVE(71), F_BASIC_MANIPULATOR(72), F_BATTLE_CLAW(73), @@ -130,13 +124,10 @@ public enum MiscTypeFlag implements IndexedFlag { F_MOBILE_HPG(101), F_FIELD_KITCHEN(102), F_MOBILE_FIELD_BASE(103), - // TODO: add game rules for the following imagers/radars, construction data - // only - F_HIRES_IMAGER(104), - F_HYPERSPECTRAL_IMAGER(105), - F_INFRARED_IMAGER(106), - F_LOOKDOWN_RADAR(107), - + F_HIRES_IMAGER(104), // TODO: add game rules for the following imagers/radars, construction data only + F_HYPERSPECTRAL_IMAGER(105), // TODO: add game rules for the following imagers/radars, construction data only + F_INFRARED_IMAGER(106), // TODO: add game rules for the following imagers/radars, construction data only + F_LOOKDOWN_RADAR(107), // TODO: add game rules for the following imagers/radars, construction data only F_COMMAND_CONSOLE(108), F_VSTOL_CHASSIS(109), F_STOL_CHASSIS(110), @@ -215,12 +206,8 @@ public enum MiscTypeFlag implements IndexedFlag { F_FLUID_SUCTION_SYSTEM(183), F_HYDROFOIL(184), F_SUBMERSIBLE(185), - - // Flag for BattleArmor Modular Equipment Adaptor - F_BA_MEA(186), - - // Flag for Infantry Equipment - F_INF_EQUIPMENT(187), + F_BA_MEA(186), // Flag for BattleArmor Modular Equipment Adaptor + F_INF_EQUIPMENT(187), // Flag for Infantry Equipment F_SCM(188), F_VIRAL_JAMMER_HOMING(189), F_VIRAL_JAMMER_DECOY(190), @@ -230,18 +217,12 @@ public enum MiscTypeFlag implements IndexedFlag { F_EMERGENCY_COOLANT_SYSTEM(194), F_BADC(195), F_REUSABLE(196), - F_BLOODHOUND(197), F_ARMOR_KIT(198), - - // Flags for Large Craft Systems - F_STORAGE_BATTERY(199), + F_STORAGE_BATTERY(199), // Flags for Large Craft Systems F_LIGHT_SAIL(200), - - // Prototype Stuff - F_ARTEMIS_PROTO(201), + F_ARTEMIS_PROTO(201), // Prototype Stuff F_CASEP(202), - F_VEEDC(203), F_SC_EQUIPMENT(204), F_DS_EQUIPMENT(205), @@ -251,10 +232,8 @@ public enum MiscTypeFlag implements IndexedFlag { F_CAPITAL_ARMOR(209), F_FERRO_CARBIDE(210), F_IMP_FERRO(211), - // Not usable by small support vehicles - F_HEAVY_EQUIPMENT(212), - // Drone Equipment for Large Craft - F_SRCS(213), + F_HEAVY_EQUIPMENT(212), // Not usable by small support vehicles + F_SRCS(213), // Drone Equipment for Large Craft F_SASRCS(214), F_CASPAR(215), F_CASPARII(216), @@ -267,8 +246,7 @@ public enum MiscTypeFlag implements IndexedFlag { F_EXTERNAL_POWER_PICKUP(223), F_RAM_PLATE(224), F_PROTOTYPE(225), - // Fortify Equipment - F_TRENCH_CAPABLE(226), + F_TRENCH_CAPABLE(226), // Fortify Equipment F_SUPPORT_VEE_BAR_ARMOR(227); private final int flagIndex; diff --git a/megamek/src/megamek/common/WeaponType.java b/megamek/src/megamek/common/WeaponType.java index 7357b8293fa..3728316c70c 100644 --- a/megamek/src/megamek/common/WeaponType.java +++ b/megamek/src/megamek/common/WeaponType.java @@ -157,7 +157,6 @@ public class WeaponType extends EquipmentType { public static final WeaponTypeFlag F_DIVE_BOMB = WeaponTypeFlag.F_DIVE_BOMB; public static final WeaponTypeFlag F_ALT_BOMB = WeaponTypeFlag.F_ALT_BOMB; - // Currently only used by MML public static final WeaponTypeFlag F_BA_WEAPON = WeaponTypeFlag.F_BA_WEAPON; public static final WeaponTypeFlag F_MEK_WEAPON = WeaponTypeFlag.F_MEK_WEAPON; public static final WeaponTypeFlag F_AERO_WEAPON = WeaponTypeFlag.F_AERO_WEAPON; diff --git a/megamek/src/megamek/common/WeaponTypeFlag.java b/megamek/src/megamek/common/WeaponTypeFlag.java index a176b33c936..040a88ef27e 100644 --- a/megamek/src/megamek/common/WeaponTypeFlag.java +++ b/megamek/src/megamek/common/WeaponTypeFlag.java @@ -15,88 +15,57 @@ /** + * 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 * @author Luana Coppio */ public enum WeaponTypeFlag implements IndexedFlag { - // weapon flags (note: many weapons can be identified by their ammo type) - // marks any weapon affected by a targeting computer - F_DIRECT_FIRE(0), + F_DIRECT_FIRE(0), // marks any weapon affected by a targeting computer F_FLAMER(1), - // Glaze armor F_LASER(2), F_PPC(3), - // for weapons that target Automatically (AMS) - F_AUTO_TARGET(4), - // can not start fires - F_NO_FIRES(5), - // must be only weapon attacking - F_SOLO_ATTACK(7), + F_AUTO_TARGET(4), // for weapons that target Automatically (AMS) + F_NO_FIRES(5), // can not start fires + F_SOLO_ATTACK(7), // must be only weapon attacking F_VGL(8), - // MGL for rapid fire setup - F_MG(9), - // Inferno weapon - F_INFERNO(10), - // Infantry caliber weapon, damage based on # of men shooting - F_INFANTRY(11), - // use missile rules for # of hits - F_MISSILE_HITS(13), + F_MG(9), // MGL for rapid fire setup + F_INFERNO(10), // Inferno weapon + F_INFANTRY(11), // Infantry caliber weapon, damage based on # of men shooting + F_MISSILE_HITS(13), // use missile rules for # of hits F_ONESHOT(14), F_ARTILLERY(15), - - // for Gunnery/Ballistic - F_BALLISTIC(16), - // for Gunnery/Energy - F_ENERGY(17), - // for Gunnery/Missile - F_MISSILE(18), - - // fires - F_PLASMA(19), - F_INCENDIARY_NEEDLES(20), - - // War of 3039 prototypes - F_PROTOTYPE(21), - // Variable heat, heat is listed in dice, not points - F_HEATASDICE(22), - // AMS - F_AMS(23), - - // may only target Infantry - F_INFANTRY_ONLY(25), - + F_BALLISTIC(16), // for Gunnery/Ballistic + F_ENERGY(17), // for Gunnery/Energy + F_MISSILE(18), // for Gunnery/Missile + F_PLASMA(19), // fires + F_INCENDIARY_NEEDLES(20), // fires + F_PROTOTYPE(21), // War of 3039 prototypes + F_HEATASDICE(22), // Variable heat, heat is listed in dice, not points + F_AMS(23), // AMS + F_INFANTRY_ONLY(25), // may only target Infantry F_TAG(26), - // C3 Master with Target Acquisition gear - F_C3M(27), - - // Plasma Rifle - F_PLASMA_MFUK(28), - // fire Extinguisher - F_EXTINGUISHER(29), + F_C3M(27), // C3 Master with Target Acquisition gear + F_PLASMA_MFUK(28), // Plasma Rifle + F_EXTINGUISHER(29), // fire Extinguisher F_PULSE(30), - // Full Damage vs. Infantry - F_BURST_FIRE(31), - // Machine Gun Array - F_MGA(32), + F_BURST_FIRE(31), // Full Damage vs. Infantry + F_MGA(32), // Machine Gun Array F_NO_AIM(33), F_BOMBAST_LASER(34), F_CRUISE_MISSILE(35), F_B_POD(36), F_TASER(37), - - // Anti-ship missiles - F_ANTI_SHIP(38), + F_ANTI_SHIP(38), // Anti-ship missiles F_SPACE_BOMB(39), F_M_POD(40), F_DIVE_BOMB(41), F_ALT_BOMB(42), - - // Currently only used by MML - F_BA_WEAPON(43), - F_MEK_WEAPON(44), - F_AERO_WEAPON(45), - F_PROTO_WEAPON(46), + F_BA_WEAPON(43), // Currently only used by MML + F_MEK_WEAPON(44), // Currently only used by MML + F_AERO_WEAPON(45), // Currently only used by MML + F_PROTO_WEAPON(46), // Currently only used by MML F_TANK_WEAPON(47), - F_INFANTRY_ATTACK(48), F_INF_BURST(49), F_INF_AA(50), @@ -105,52 +74,22 @@ public enum WeaponTypeFlag implements IndexedFlag { F_INF_SUPPORT(53), F_INF_ENCUMBER(54), F_INF_ARCHAIC(55), - - // TODO Add game rules IO pg 84 - F_INF_CLIMBINGCLAWS(63), - - // C3 Master Booster System - F_C3MBS(56), - - // Naval Mass Drivers - F_MASS_DRIVER(58), - + F_INF_CLIMBINGCLAWS(63), // TODO Add game rules IO pg 84 + F_C3MBS(56), // C3 Master Booster System + F_MASS_DRIVER(58), // Naval Mass Drivers F_CWS(59), - F_MEK_MORTAR(60), - - // Weapon required to make a bomb type function - F_BOMB_WEAPON(61), - + F_BOMB_WEAPON(61), // Weapon required to make a bomb type function F_BA_INDIVIDUAL(62), - // Next one's out of order. See F_INF_CLIMBINGCLAWS - - // AMS and Point Defense Bays - Have to work differently from code using the - // F_AMS flag - F_PDBAY(64), - F_AMSBAY(65), - - // Thunderbolt and similar large missiles, for use with AMS resolution - F_LARGEMISSILE(66), - - // Hyper-Laser - F_HYPER(67), - - // Fusillade works like a one-shot weapon but has a second round. - F_DOUBLE_ONESHOT(68), - // ER flamers do half damage in heat mode - F_ER_FLAMER(69), - /** Missile weapon that can be linked to an Artemis fire control system */ - F_ARTEMIS_COMPATIBLE(70), - - /** - * This flag is used by mortar-type weapons that allow indirect fire without a - * spotter and/or with LOS. - */ - F_MORTARTYPE_INDIRECT(71), - - // Used for TSEMP Weapons. - F_TSEMP(57), + F_PDBAY(64), // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag + F_AMSBAY(65), // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag + F_LARGEMISSILE(66), // Thunderbolt and similar large missiles, for use with AMS resolution + F_HYPER(67), // Hyper-Laser + F_DOUBLE_ONESHOT(68), // Fusillade works like a one-shot weapon but has a second round. + F_ER_FLAMER(69), // ER flamers do half damage in heat mode + F_ARTEMIS_COMPATIBLE(70), // Missile weapon that can be linked to an Artemis fire control system + F_MORTARTYPE_INDIRECT(71), // This flag is used by mortar-type weapons that allow indirect fire without a spotter and/or with LOS. + F_TSEMP(57), // Used for TSEMP Weapons. F_REPEATING(72); private final int flagIndex; From b1228417eecd1ed43ba9fa30e4774916e7bd516b Mon Sep 17 00:00:00 2001 From: Scoppio Date: Fri, 31 Jan 2025 22:04:58 -0300 Subject: [PATCH 3/4] chore: reorganizing enums, removing unnecessary values, simplifying stuff --- .../src/megamek/client/ui/swing/MapMenu.java | 2 +- megamek/src/megamek/common/AmmoTypeFlag.java | 62 ++- megamek/src/megamek/common/Entity.java | 16 +- .../src/megamek/common/EquipmentBitSet.java | 39 +- .../{IndexedFlag.java => EquipmentFlag.java} | 2 +- megamek/src/megamek/common/EquipmentType.java | 2 +- megamek/src/megamek/common/Mek.java | 4 +- megamek/src/megamek/common/MiscTypeFlag.java | 518 ++++++++++-------- .../src/megamek/common/WeaponTypeFlag.java | 169 +++--- .../common/pathfinder/CachedEntityState.java | 4 +- .../verifier/TestAdvancedAerospace.java | 4 +- .../common/verifier/TestSmallCraft.java | 2 +- .../client/bot/princess/FireControlTest.java | 6 +- 13 files changed, 455 insertions(+), 375 deletions(-) rename megamek/src/megamek/common/{IndexedFlag.java => EquipmentFlag.java} (97%) diff --git a/megamek/src/megamek/client/ui/swing/MapMenu.java b/megamek/src/megamek/client/ui/swing/MapMenu.java index 4b26b4dcb6c..533a2b0131f 100644 --- a/megamek/src/megamek/client/ui/swing/MapMenu.java +++ b/megamek/src/megamek/client/ui/swing/MapMenu.java @@ -1611,7 +1611,7 @@ private boolean hasAmmoType(int ammoType) { return false; } - private boolean hasWeaponFlag(IndexedFlag weaponFlag) { + private boolean hasWeaponFlag(EquipmentFlag weaponFlag) { if (myEntity.getWeaponList().isEmpty()) { return false; } diff --git a/megamek/src/megamek/common/AmmoTypeFlag.java b/megamek/src/megamek/common/AmmoTypeFlag.java index 0214b4fcbd8..0648befddbf 100644 --- a/megamek/src/megamek/common/AmmoTypeFlag.java +++ b/megamek/src/megamek/common/AmmoTypeFlag.java @@ -18,39 +18,41 @@ * special properties * @author Luana Coppio */ -public enum AmmoTypeFlag implements IndexedFlag { - F_MG(0), // Machinegun ammo - F_BATTLEARMOR(1), // only used by BA squads - F_PROTOMEK(2), // only used by ProtoMeks - F_HOTLOAD(3), // Ammo can be hotloaded - F_ENCUMBERING(4), // Encumbering ammo - if loaded on a BA it cant jump or make anti-mek attacks until dumped - F_AR10_WHITE_SHARK(6), // White shark type - F_AR10_KILLER_WHALE(7), // Killer Whale type - F_AR10_BARRACUDA(8), // barracuda type - F_NUCLEAR(9), // Nuclear missile - F_SANTA_ANNA(14), // Nuke Santa Anna Missile - F_PEACEMAKER(15), // Nuke Peacemaker Missile - F_TELE_MISSILE(10), // Tele-Missile - F_CAP_MISSILE(11), // Other Capital-Missile - F_SPACE_BOMB(12), // defines that the ammo can be used to space bomb - F_GROUND_BOMB(13), // the ammo can be used to ground bomb - F_MML_LRM(5), // LRM type - F_MML_SRM(14), // SRM type - F_OTHER_BOMB(16), // For tag, rl pods, missiles and the like - F_CRUISE_MISSILE(17), // Used by MHQ for loading ammo bins - F_SCREEN(18), // Used by MHQ for loading ammo bins - F_INTERNAL_BOMB(19); // Used for Internal Bomb Bay bombs; to differentiate them from other bombs - - private final int flagIndex; - - AmmoTypeFlag(int flagIndex) { - assert flagIndex >= 0; - this.flagIndex = flagIndex; - } +public enum AmmoTypeFlag implements EquipmentFlag { + + F_BATTLEARMOR, // only used by BA squads + F_PROTOMEK, // only used by ProtoMeks + + F_ENCUMBERING, // Encumbering ammo - if loaded on a BA it cant jump or make anti-mek attacks until dumped + + F_MG, // Machinegun ammo + F_MML_LRM, // LRM type + F_MML_SRM, // SRM type + + F_HOTLOAD, // Ammo can be hotloaded + + F_SCREEN, // Used by MHQ for loading ammo bins + + F_INTERNAL_BOMB, // Used for Internal Bomb Bay bombs; to differentiate them from other bombs + F_GROUND_BOMB, // the ammo can be used to ground bomb + F_OTHER_BOMB, // For tag, rl pods, missiles and the like + F_SPACE_BOMB, // defines that the ammo can be used to space bomb + + F_AR10_BARRACUDA, // barracuda type + F_AR10_KILLER_WHALE, // Killer Whale type + F_AR10_WHITE_SHARK, // White shark type + F_CAP_MISSILE, // Other Capital-Missile + F_CRUISE_MISSILE, // Used by MHQ for loading ammo bins + F_TELE_MISSILE, // Tele-Missile + + F_NUCLEAR, // Nuclear missile + F_SANTA_ANNA, // Nuke Santa Anna Missile + F_PEACEMAKER; // Nuke Peacemaker Missile + @Override public int getFlagIndex() { - return flagIndex; + return this.ordinal(); } } diff --git a/megamek/src/megamek/common/Entity.java b/megamek/src/megamek/common/Entity.java index ea463a715b4..3d8948758e9 100644 --- a/megamek/src/megamek/common/Entity.java +++ b/megamek/src/megamek/common/Entity.java @@ -4469,7 +4469,7 @@ public List getBombs() { * @return The list of found bombs * @see Mounted#isOperable() */ - public List getBombs(IndexedFlag flag) { + public List getBombs(EquipmentFlag flag) { return getBombs().stream() .filter(b -> b.getType().hasFlag(flag)) .filter(Mounted::isOperable) @@ -4631,7 +4631,7 @@ public List getClubs() { * @param flag A MiscType.F_XXX * @return true if at least one ready item. */ - public boolean hasWorkingMisc(IndexedFlag flag) { + public boolean hasWorkingMisc(EquipmentFlag flag) { return hasWorkingMisc(flag, -1); } @@ -4642,7 +4642,7 @@ public boolean hasWorkingMisc(IndexedFlag flag) { * @param secondary A MiscType.S_XXX or -1 for don't care * @return true if at least one ready item. */ - public boolean hasWorkingMisc(IndexedFlag flag, long secondary) { + public boolean hasWorkingMisc(EquipmentFlag flag, long secondary) { for (MiscMounted m : miscList) { if (m.isReady() && m.getType().hasFlag(flag) && ((secondary == -1) || m.getType().hasSubType(secondary))) { @@ -4652,11 +4652,11 @@ public boolean hasWorkingMisc(IndexedFlag flag, long secondary) { return false; } - public boolean hasMisc(IndexedFlag flag) { + public boolean hasMisc(EquipmentFlag flag) { return miscList.stream().anyMatch(misc -> misc.getType().hasFlag(flag)); } - public List getMiscEquipment(IndexedFlag flag) { + public List getMiscEquipment(EquipmentFlag flag) { return miscList.stream() .filter(item -> item.getType().hasFlag(flag)) .collect(Collectors.toList()); @@ -4681,11 +4681,11 @@ public long countEquipment(String internalName) { * @param flag * @return */ - public int countWorkingMisc(IndexedFlag flag) { + public int countWorkingMisc(EquipmentFlag flag) { return countWorkingMisc(flag, -1); } - public int countWorkingMisc(IndexedFlag flag, int location) { + public int countWorkingMisc(EquipmentFlag flag, int location) { int count = 0; OUTER: for (MiscMounted m : getMisc()) { if (!m.isInoperable() && m.getType().hasFlag(flag) @@ -4744,7 +4744,7 @@ public boolean hasWorkingMisc(String name) { * @param location The location to check e.g. Mek.LOC_LARM * @return true if at least one ready item. */ - public boolean hasWorkingMisc(IndexedFlag flag, long secondary, int location) { + public boolean hasWorkingMisc(EquipmentFlag flag, long secondary, int location) { // go through the location slot by slot, because of misc equipment that // is spreadable for (int slot = 0; slot < getNumberOfCriticals(location); slot++) { diff --git a/megamek/src/megamek/common/EquipmentBitSet.java b/megamek/src/megamek/common/EquipmentBitSet.java index 9faa551af6b..b4c637d085b 100644 --- a/megamek/src/megamek/common/EquipmentBitSet.java +++ b/megamek/src/megamek/common/EquipmentBitSet.java @@ -1,3 +1,16 @@ +/* + * Copyright (c) 2025 - The MegaMek Team. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ package megamek.common; import java.util.BitSet; @@ -16,7 +29,11 @@ public class EquipmentBitSet { * Default constructor. */ public EquipmentBitSet() { - this.bitSet = new BitSet(MiscTypeFlag.values().length + AmmoTypeFlag.values().length + WeaponTypeFlag.values().length); + // This value is currently a bit above the double of what we need, but it's a power of 2, and it's a good + // starting point since it will give a lot of runaway for new types of equipments, ammo and weapons to be added + // Whenever we surpass this number, the bitset will increase on its own as needed, so its more of a performance + // matter than a limitation. + this.bitSet = new BitSet(512); } /** @@ -32,7 +49,7 @@ public EquipmentBitSet(EquipmentBitSet other) { * @param flag the flag to check * @return true if the flag is set in the EquipmentBitSet */ - public boolean get(IndexedFlag flag) { + public boolean get(EquipmentFlag flag) { return bitSet.get(flag.getFlagIndex()); } @@ -46,7 +63,7 @@ public boolean contains(EquipmentBitSet other) { * Clears the flag in the EquipmentBitSet. * @param flag the flag to clear */ - public void clear(IndexedFlag flag) { + public void clear(EquipmentFlag flag) { bitSet.clear(flag.getFlagIndex()); } @@ -61,7 +78,7 @@ public void clear() { * Sets the flag in the EquipmentBitSet. * @param flag the flag to set */ - public void set(IndexedFlag flag) { + public void set(EquipmentFlag flag) { bitSet.set(flag.getFlagIndex()); } @@ -71,7 +88,7 @@ public void set(IndexedFlag flag) { * @param flag the flag to set * @return a copy of this EquipmentBitSet with the flag set */ - public EquipmentBitSet or(IndexedFlag flag) { + public EquipmentBitSet or(EquipmentFlag flag) { var newBitSet = new EquipmentBitSet(this); newBitSet.set(flag); return newBitSet; @@ -82,7 +99,7 @@ public EquipmentBitSet or(IndexedFlag flag) { * @param flag the flag to clear * @return a copy of this EquipmentBitSet with the flag cleared */ - public EquipmentBitSet andNot(IndexedFlag flag) { + public EquipmentBitSet andNot(EquipmentFlag flag) { var newBitSet = new EquipmentBitSet(this); newBitSet.clear(flag); return newBitSet; @@ -100,7 +117,7 @@ public EquipmentBitSet andNot(IndexedFlag flag) { * @param flag the flag to check * @return a new empty EquipmentBitSet and the flag set if it is set in this EquipmentBitSet */ - public EquipmentBitSet and(IndexedFlag flag) { + public EquipmentBitSet and(EquipmentFlag flag) { var newBitSet = new EquipmentBitSet(); if (this.get(flag)) { newBitSet.set(flag); @@ -117,9 +134,11 @@ public String toString() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; - EquipmentBitSet that = (EquipmentBitSet) o; - return Objects.equals(bitSet, that.bitSet); + if (o instanceof EquipmentBitSet that) { + return Objects.equals(bitSet, that.bitSet); + } + + return false; } @Override diff --git a/megamek/src/megamek/common/IndexedFlag.java b/megamek/src/megamek/common/EquipmentFlag.java similarity index 97% rename from megamek/src/megamek/common/IndexedFlag.java rename to megamek/src/megamek/common/EquipmentFlag.java index 7bb1096f841..150b961701c 100644 --- a/megamek/src/megamek/common/IndexedFlag.java +++ b/megamek/src/megamek/common/EquipmentFlag.java @@ -21,7 +21,7 @@ * multiple flags can be composed into an {@link EquipmentBitSet}. * @author Luana Coppio */ -public interface IndexedFlag { +public interface EquipmentFlag { /** * Returns the index of the flag in the bitset * - Future improvements, return ordinal instead of arbitrary index diff --git a/megamek/src/megamek/common/EquipmentType.java b/megamek/src/megamek/common/EquipmentType.java index 2d47a7789f1..0058f565fcc 100644 --- a/megamek/src/megamek/common/EquipmentType.java +++ b/megamek/src/megamek/common/EquipmentType.java @@ -509,7 +509,7 @@ public EquipmentBitSet getFlags() { return flags; } - public boolean hasFlag(IndexedFlag flag) { + public boolean hasFlag(EquipmentFlag flag) { return flags.get(flag); } diff --git a/megamek/src/megamek/common/Mek.java b/megamek/src/megamek/common/Mek.java index 7e9fff6ad18..36e1717d871 100644 --- a/megamek/src/megamek/common/Mek.java +++ b/megamek/src/megamek/common/Mek.java @@ -1391,7 +1391,7 @@ public int height() { * Adds heat sinks to the engine. Uses clan/normal depending on the * currently set techLevel */ - public void addEngineSinks(int totalSinks, IndexedFlag heatSinkFlag) { + public void addEngineSinks(int totalSinks, EquipmentFlag heatSinkFlag) { addEngineSinks(totalSinks, heatSinkFlag, isClan()); } @@ -1399,7 +1399,7 @@ public void addEngineSinks(int totalSinks, IndexedFlag heatSinkFlag) { * Adds heat sinks to the engine. Adds either the engine capacity, or the * entire number of heat sinks, whichever is less */ - public void addEngineSinks(int totalSinks, IndexedFlag heatSinkFlag, + public void addEngineSinks(int totalSinks, EquipmentFlag heatSinkFlag, boolean clan) { if (heatSinkFlag == MiscType.F_DOUBLE_HEAT_SINK) { addEngineSinks(totalSinks, clan ? EquipmentTypeLookup.CLAN_DOUBLE_HS diff --git a/megamek/src/megamek/common/MiscTypeFlag.java b/megamek/src/megamek/common/MiscTypeFlag.java index 95e17397fe3..325ed87bb89 100644 --- a/megamek/src/megamek/common/MiscTypeFlag.java +++ b/megamek/src/megamek/common/MiscTypeFlag.java @@ -19,246 +19,290 @@ * Every type of equipment has its own flag. * @author Luana Coppio */ -public enum MiscTypeFlag implements IndexedFlag { - F_HEAT_SINK(0), - F_DOUBLE_HEAT_SINK(1), - F_JUMP_JET(2), - F_CASE(3), - F_MASC(4), - F_TSM(5), - F_LASER_HEAT_SINK(6), - F_C3S(7), - F_C3I(8), - F_ARTEMIS(9), - F_TARGCOMP(10), - F_ANGEL_ECM(11), - F_BOARDING_CLAW(12), - F_VACUUM_PROTECTION(13), - F_MAGNET_CLAW(14), - F_FIRE_RESISTANT(15), - F_STEALTH(16), - F_MINE(17), - F_TOOLS(18), - F_MAGNETIC_CLAMP(19), - F_PARAFOIL(20), - F_FERRO_FIBROUS(21), - F_ENDO_STEEL(22), - F_AP_POD(23), - F_SEARCHLIGHT(24), - F_CLUB(25), - F_HAND_WEAPON(26), - F_COWL(27), - F_JUMP_BOOSTER(28), - F_HARJEL(29), - F_UMU(30), - F_BA_VTOL(31), - F_SPIKES(32), - F_COMMUNICATIONS(33), - F_PPC_CAPACITOR(34), - F_REFLECTIVE(35), - F_REACTIVE(36), - F_CASEII(37), - F_LIFTHOIST(38), - F_ENVIRONMENTAL_SEALING(39), - F_ARMORED_CHASSIS(40), - F_TRACTOR_MODIFICATION(41), - F_ACTUATOR_ENHANCEMENT_SYSTEM(42), - F_ECM(43), - F_BAP(44), - F_MODULAR_ARMOR(45), - F_TALON(46), - F_VISUAL_CAMO(47), - F_APOLLO(48), - F_INDUSTRIAL_TSM(49), - F_NULLSIG(50), - F_VOIDSIG(51), - F_CHAMELEON_SHIELD(52), - F_VIBROCLAW(53), - F_SINGLE_HEX_ECM(54), - F_EJECTION_SEAT(55), - F_SALVAGE_ARM(56), - F_PARTIAL_WING(57), - F_FERRO_LAMELLOR(58), - F_ARTEMIS_V(59), - F_TRACKS(60), // TODO: Implement me, so far only construction data - F_MASS(61), // TODO: Implement me, so far only construction data - F_CARGO(62), // TODO: Implement me, so far only construction data - F_DUMPER(63), // TODO: Implement me, so far only construction data - F_MASH(64), // TODO: Implement me, so far only construction data - F_BA_EQUIPMENT(65), - F_MEK_EQUIPMENT(66), - F_TANK_EQUIPMENT(67), - F_FIGHTER_EQUIPMENT(68), - F_SUPPORT_TANK_EQUIPMENT(69), - F_PROTOMEK_EQUIPMENT(70), - F_ARMORED_GLOVE(71), - F_BASIC_MANIPULATOR(72), - F_BATTLE_CLAW(73), - F_AP_MOUNT(74), - F_MAST_MOUNT(75), - F_FUEL(76), - F_BLUE_SHIELD(77), - F_BASIC_FIRECONTROL(78), - F_ADVANCED_FIRECONTROL(79), - F_ENDO_COMPOSITE(80), - F_LASER_INSULATOR(81), - F_LIQUID_CARGO(82), - F_WATCHDOG(83), - F_EW_EQUIPMENT(84), - F_CCM(85), - F_HITCH(86), - F_FLOTATION_HULL(87), - F_LIMITED_AMPHIBIOUS(88), - F_FULLY_AMPHIBIOUS(89), - F_DUNE_BUGGY(90), - F_SHOULDER_TURRET(91), - F_HEAD_TURRET(92), - F_QUAD_TURRET(93), - F_SPACE_ADAPTATION(94), - F_CUTTING_TORCH(95), - F_OFF_ROAD(96), - F_C3SBS(97), - F_VTOL_EQUIPMENT(98), - F_NAVAL_C3(99), - F_MINESWEEPER(100), - F_MOBILE_HPG(101), - F_FIELD_KITCHEN(102), - F_MOBILE_FIELD_BASE(103), - F_HIRES_IMAGER(104), // TODO: add game rules for the following imagers/radars, construction data only - F_HYPERSPECTRAL_IMAGER(105), // TODO: add game rules for the following imagers/radars, construction data only - F_INFRARED_IMAGER(106), // TODO: add game rules for the following imagers/radars, construction data only - F_LOOKDOWN_RADAR(107), // TODO: add game rules for the following imagers/radars, construction data only - F_COMMAND_CONSOLE(108), - F_VSTOL_CHASSIS(109), - F_STOL_CHASSIS(110), - F_SPONSON_TURRET(111), - F_ARMORED_MOTIVE_SYSTEM(112), - F_CHASSIS_MODIFICATION(113), - F_CHAFF_POD(114), - F_DRONE_CARRIER_CONTROL(115), - F_VARIABLE_SIZE(116), - F_BA_MISSION_EQUIPMENT(117), - F_JET_BOOSTER(118), - F_SENSOR_DISPENSER(119), - F_DRONE_OPERATING_SYSTEM(120), - F_RECON_CAMERA(121), - F_COMBAT_VEHICLE_ESCAPE_POD(122), - F_DETACHABLE_WEAPON_PACK(123), - F_HEAT_SENSOR(124), - F_EXTENDED_LIFESUPPORT(125), - F_SPRAYER(126), - F_ELECTRIC_DISCHARGE_ARMOR(127), - F_MECHANICAL_JUMP_BOOSTER(128), - F_TRAILER_MODIFICATION(129), - F_LARGE_COMM_SCANNER_SUITE(130), - F_SMALL_COMM_SCANNER_SUITE(131), - F_LIGHT_BRIDGE_LAYER(132), - F_MEDIUM_BRIDGE_LAYER(133), - F_HEAVY_BRIDGE_LAYER(134), - F_BA_SEARCHLIGHT(135), - F_BOOBY_TRAP(136), - F_SPLITABLE(137), - F_REFUELING_DROGUE(138), - F_BULLDOZER(139), - F_EXTERNAL_STORES_HARDPOINT(140), - F_COMPACT_HEAT_SINK(141), - F_MANIPULATOR(142), - F_CARGOLIFTER(143), - F_PINTLE_TURRET(144), - F_IS_DOUBLE_HEAT_SINK_PROTOTYPE(145), - F_NAVAL_TUG_ADAPTOR(146), - F_AMPHIBIOUS(147), - F_PROP(148), - F_ULTRA_LIGHT(149), - F_SPACE_MINE_DISPENSER(150), - F_VEHICLE_MINE_DISPENSER(151), - F_LIGHT_FERRO(152), - F_HEAVY_FERRO(153), - F_FERRO_FIBROUS_PROTO(154), - F_REINFORCED(155), - F_COMPOSITE(156), - F_INDUSTRIAL_STRUCTURE(157), - F_ENDO_STEEL_PROTO(158), - F_INDUSTRIAL_ARMOR(159), - F_HEAVY_INDUSTRIAL_ARMOR(160), - F_PRIMITIVE_ARMOR(161), - F_HARDENED_ARMOR(162), - F_COMMERCIAL_ARMOR(163), - F_C3EM(164), - F_ANTI_PENETRATIVE_ABLATIVE(165), - F_HEAT_DISSIPATING(166), - F_IMPACT_RESISTANT(167), - F_BALLISTIC_REINFORCED(168), - F_HARJEL_II(169), - F_HARJEL_III(170), - F_RADICAL_HEATSINK(171), - F_BA_MANIPULATOR(172), - F_NOVA(173), - F_BOMB_BAY(174), - F_LIGHT_FLUID_SUCTION_SYSTEM(175), - F_MONOCYCLE(176), - F_BICYCLE(177), - F_CONVERTIBLE(178), - F_BATTLEMEK_NIU(179), - F_SNOWMOBILE(180), - F_LADDER(181), - F_LIFEBOAT(182), - F_FLUID_SUCTION_SYSTEM(183), - F_HYDROFOIL(184), - F_SUBMERSIBLE(185), - F_BA_MEA(186), // Flag for BattleArmor Modular Equipment Adaptor - F_INF_EQUIPMENT(187), // Flag for Infantry Equipment - F_SCM(188), - F_VIRAL_JAMMER_HOMING(189), - F_VIRAL_JAMMER_DECOY(190), - F_DRONE_CONTROL_CONSOLE(191), - F_RISC_LASER_PULSE_MODULE(192), - F_REMOTE_DRONE_COMMAND_CONSOLE(193), - F_EMERGENCY_COOLANT_SYSTEM(194), - F_BADC(195), - F_REUSABLE(196), - F_BLOODHOUND(197), - F_ARMOR_KIT(198), - F_STORAGE_BATTERY(199), // Flags for Large Craft Systems - F_LIGHT_SAIL(200), - F_ARTEMIS_PROTO(201), // Prototype Stuff - F_CASEP(202), - F_VEEDC(203), - F_SC_EQUIPMENT(204), - F_DS_EQUIPMENT(205), - F_JS_EQUIPMENT(206), - F_WS_EQUIPMENT(207), - F_SS_EQUIPMENT(208), - F_CAPITAL_ARMOR(209), - F_FERRO_CARBIDE(210), - F_IMP_FERRO(211), - F_HEAVY_EQUIPMENT(212), // Not usable by small support vehicles - F_SRCS(213), // Drone Equipment for Large Craft - F_SASRCS(214), - F_CASPAR(215), - F_CASPARII(216), - F_ATAC(217), - F_DTAC(218), - F_SDS_DESTRUCT(219), - F_SDS_JAMMER(220), - F_LF_STORAGE_BATTERY(221), - F_PROTOMEK_MELEE(222), - F_EXTERNAL_POWER_PICKUP(223), - F_RAM_PLATE(224), - F_PROTOTYPE(225), - F_TRENCH_CAPABLE(226), // Fortify Equipment - F_SUPPORT_VEE_BAR_ARMOR(227); - - private final int flagIndex; - - MiscTypeFlag(int flagIndex) { - assert flagIndex >= 0; - this.flagIndex = flagIndex; - } +public enum MiscTypeFlag implements EquipmentFlag { + // Heat sink family + F_HEAT_SINK, + F_DOUBLE_HEAT_SINK, + F_LASER_HEAT_SINK, + F_COMPACT_HEAT_SINK, + F_IS_DOUBLE_HEAT_SINK_PROTOTYPE, + F_RADICAL_HEATSINK, + F_LASER_INSULATOR, + F_HEAT_DISSIPATING, + + // Limit which type of unit can install the equipment + F_BA_EQUIPMENT, + F_MEK_EQUIPMENT, + F_TANK_EQUIPMENT, + F_FIGHTER_EQUIPMENT, + F_SUPPORT_TANK_EQUIPMENT, + F_PROTOMEK_EQUIPMENT, + + F_JUMP_JET, + F_JUMP_BOOSTER, + F_MECHANICAL_JUMP_BOOSTER, + + F_CASE, + F_CASEII, + F_CASEP, + + F_MASC, + F_TSM, + F_INDUSTRIAL_TSM, + + F_C3S, + F_C3I, + F_C3EM, + F_C3SBS, + F_NAVAL_C3, + + F_ARTEMIS, + F_TARGCOMP, + F_ARTEMIS_V, + + F_BATTLEMEK_NIU, + + F_SEARCHLIGHT, + F_BA_SEARCHLIGHT, + + F_ANGEL_ECM, + F_ECM, + F_WATCHDOG, + F_EW_EQUIPMENT, + F_CCM, + F_SINGLE_HEX_ECM, + + F_MAGNETIC_CLAMP, + F_BOARDING_CLAW, + F_MAGNET_CLAW, + F_BA_MANIPULATOR, + F_ARMORED_GLOVE, + F_BASIC_MANIPULATOR, + F_BATTLE_CLAW, + + F_PROTOMEK_MELEE, + + F_BOOBY_TRAP, + F_MINE, + F_SPACE_MINE_DISPENSER, + F_VEHICLE_MINE_DISPENSER, + F_MINESWEEPER, + + F_AP_POD, + F_CLUB, + F_HAND_WEAPON, + F_COWL, + F_BA_VTOL, + F_UMU, + F_TALON, + F_SPIKES, + F_COMMUNICATIONS, + + F_PPC_CAPACITOR, + + F_ENVIRONMENTAL_SEALING, + F_ARMORED_CHASSIS, + F_TRACTOR_MODIFICATION, + F_ACTUATOR_ENHANCEMENT_SYSTEM, + + F_BAP, + F_VISUAL_CAMO, + F_APOLLO, + + F_NULLSIG, + F_VOIDSIG, + F_LIFTHOIST, + F_CHAMELEON_SHIELD, + F_VIBROCLAW, + + F_EJECTION_SEAT, + F_SALVAGE_ARM, + F_PARTIAL_WING, + + F_TRACKS, // TODO: Implement me, so far only construction data + F_MASS, // TODO: Implement me, so far only construction data + F_CARGO, // TODO: Implement me, so far only construction data + F_DUMPER, // TODO: Implement me, so far only construction data + F_MASH, // TODO: Implement me, so far only construction data + + + F_AP_MOUNT, + F_MAST_MOUNT, + F_FUEL, + F_BLUE_SHIELD, + F_BASIC_FIRECONTROL, + F_ADVANCED_FIRECONTROL, + F_LIQUID_CARGO, + F_HITCH, + F_FLOTATION_HULL, + F_LIMITED_AMPHIBIOUS, + F_FULLY_AMPHIBIOUS, + F_DUNE_BUGGY, + F_SPACE_ADAPTATION, + F_VACUUM_PROTECTION, + F_CUTTING_TORCH, + F_OFF_ROAD, + F_VTOL_EQUIPMENT, + + + F_MOBILE_HPG, + F_MOBILE_FIELD_BASE, + F_COMMAND_CONSOLE, + F_VSTOL_CHASSIS, + F_STOL_CHASSIS, + F_ARMORED_MOTIVE_SYSTEM, + F_CHASSIS_MODIFICATION, + F_CHAFF_POD, + F_DRONE_CARRIER_CONTROL, + F_BA_MISSION_EQUIPMENT, + F_JET_BOOSTER, + F_SENSOR_DISPENSER, + F_DRONE_OPERATING_SYSTEM, + F_RECON_CAMERA, + F_COMBAT_VEHICLE_ESCAPE_POD, + F_DETACHABLE_WEAPON_PACK, + F_SPRAYER, + F_EXTENDED_LIFESUPPORT, + + F_SHOULDER_TURRET, + F_HEAD_TURRET, + F_QUAD_TURRET, + F_PINTLE_TURRET, + F_SPONSON_TURRET, + + F_TRAILER_MODIFICATION, + F_LARGE_COMM_SCANNER_SUITE, + F_SMALL_COMM_SCANNER_SUITE, + + F_LIGHT_BRIDGE_LAYER, + F_MEDIUM_BRIDGE_LAYER, + F_HEAVY_BRIDGE_LAYER, + + F_REFUELING_DROGUE, + F_BULLDOZER, + F_EXTERNAL_STORES_HARDPOINT, + F_MANIPULATOR, + F_CARGOLIFTER, + F_NAVAL_TUG_ADAPTOR, + F_AMPHIBIOUS, + F_PROP, + F_PARAFOIL, + F_LIGHT_SAIL, + F_ULTRA_LIGHT, + + + F_ELECTRIC_DISCHARGE_ARMOR, + F_ENDO_STEEL, + F_FERRO_FIBROUS, + F_LIGHT_FERRO, + F_HEAVY_FERRO, + F_FERRO_FIBROUS_PROTO, + F_REINFORCED, + F_COMPOSITE, + F_INDUSTRIAL_STRUCTURE, + F_ENDO_STEEL_PROTO, + F_INDUSTRIAL_ARMOR, + F_HEAVY_INDUSTRIAL_ARMOR, + F_PRIMITIVE_ARMOR, + F_HARDENED_ARMOR, + F_COMMERCIAL_ARMOR, + F_IMPACT_RESISTANT, + F_BALLISTIC_REINFORCED, + F_ANTI_PENETRATIVE_ABLATIVE, + F_FIRE_RESISTANT, + F_STEALTH, + F_MODULAR_ARMOR, + F_FERRO_LAMELLOR, + F_ENDO_COMPOSITE, + F_REFLECTIVE, + F_REACTIVE, + + F_HARJEL, + F_HARJEL_II, + F_HARJEL_III, + + F_NOVA, + F_BOMB_BAY, + + F_MONOCYCLE, + F_BICYCLE, + F_CONVERTIBLE, + + F_SNOWMOBILE, + + F_LADDER, + F_LIFEBOAT, + F_HYDROFOIL, + F_SUBMERSIBLE, + F_HEAT_SENSOR, + + + F_BA_MEA, // Flag for BattleArmor Modular Equipment Adaptor + F_INF_EQUIPMENT, // Flag for Infantry Equipment + + F_SCM, + + F_VIRAL_JAMMER_HOMING, + F_VIRAL_JAMMER_DECOY, + F_DRONE_CONTROL_CONSOLE, + F_RISC_LASER_PULSE_MODULE, + F_REMOTE_DRONE_COMMAND_CONSOLE, + F_EMERGENCY_COOLANT_SYSTEM, + F_BADC, + F_REUSABLE, + F_BLOODHOUND, + F_ARMOR_KIT, + + F_ARTEMIS_PROTO, // Prototype Stuff + F_STORAGE_BATTERY, // Flags for Large Craft Systems + + F_VEEDC, + F_SC_EQUIPMENT, + F_DS_EQUIPMENT, + F_JS_EQUIPMENT, + F_WS_EQUIPMENT, + F_SS_EQUIPMENT, + F_CAPITAL_ARMOR, + + F_FERRO_CARBIDE, + F_IMP_FERRO, + F_HEAVY_EQUIPMENT, // Not usable by small support vehicles + F_SRCS, // Drone Equipment for Large Craft + F_SASRCS, + + F_CASPAR, + F_CASPARII, + + F_ATAC, + F_DTAC, + F_SDS_DESTRUCT, + F_SDS_JAMMER, + F_LF_STORAGE_BATTERY, + + F_TRENCH_CAPABLE, // Fortify Equipment + F_EXTERNAL_POWER_PICKUP, + F_PROTOTYPE, + F_TOOLS, + F_FLUID_SUCTION_SYSTEM, + F_LIGHT_FLUID_SUCTION_SYSTEM, + F_RAM_PLATE, + F_SUPPORT_VEE_BAR_ARMOR, + F_FIELD_KITCHEN, + + + F_SPLITABLE, // Marks the equipament as something that can be split betwen multiple crit slots + F_VARIABLE_SIZE, // marks the equipment as being something with a size that can be changed at will + + // Satellite Equipment + F_HIRES_IMAGER, // TODO: add game rules for the following imagers/radars, construction data only + F_HYPERSPECTRAL_IMAGER, // TODO: add game rules for the following imagers/radars, construction data only + F_INFRARED_IMAGER, // TODO: add game rules for the following imagers/radars, construction data only + F_LOOKDOWN_RADAR, // TODO: add game rules for the following imagers/radars, construction data only + ; @Override public int getFlagIndex() { - return flagIndex; + return this.ordinal(); } diff --git a/megamek/src/megamek/common/WeaponTypeFlag.java b/megamek/src/megamek/common/WeaponTypeFlag.java index 040a88ef27e..ecc45421de3 100644 --- a/megamek/src/megamek/common/WeaponTypeFlag.java +++ b/megamek/src/megamek/common/WeaponTypeFlag.java @@ -20,88 +20,103 @@ * note: many weapons can be identified by their ammo type * @author Luana Coppio */ -public enum WeaponTypeFlag implements IndexedFlag { - F_DIRECT_FIRE(0), // marks any weapon affected by a targeting computer - F_FLAMER(1), - F_LASER(2), - F_PPC(3), - F_AUTO_TARGET(4), // for weapons that target Automatically (AMS) - F_NO_FIRES(5), // can not start fires - F_SOLO_ATTACK(7), // must be only weapon attacking - F_VGL(8), - F_MG(9), // MGL for rapid fire setup - F_INFERNO(10), // Inferno weapon - F_INFANTRY(11), // Infantry caliber weapon, damage based on # of men shooting - F_MISSILE_HITS(13), // use missile rules for # of hits - F_ONESHOT(14), - F_ARTILLERY(15), - F_BALLISTIC(16), // for Gunnery/Ballistic - F_ENERGY(17), // for Gunnery/Energy - F_MISSILE(18), // for Gunnery/Missile - F_PLASMA(19), // fires - F_INCENDIARY_NEEDLES(20), // fires - F_PROTOTYPE(21), // War of 3039 prototypes - F_HEATASDICE(22), // Variable heat, heat is listed in dice, not points - F_AMS(23), // AMS - F_INFANTRY_ONLY(25), // may only target Infantry - F_TAG(26), - F_C3M(27), // C3 Master with Target Acquisition gear - F_PLASMA_MFUK(28), // Plasma Rifle - F_EXTINGUISHER(29), // fire Extinguisher - F_PULSE(30), - F_BURST_FIRE(31), // Full Damage vs. Infantry - F_MGA(32), // Machine Gun Array - F_NO_AIM(33), - F_BOMBAST_LASER(34), - F_CRUISE_MISSILE(35), - F_B_POD(36), - F_TASER(37), - F_ANTI_SHIP(38), // Anti-ship missiles - F_SPACE_BOMB(39), - F_M_POD(40), - F_DIVE_BOMB(41), - F_ALT_BOMB(42), - F_BA_WEAPON(43), // Currently only used by MML - F_MEK_WEAPON(44), // Currently only used by MML - F_AERO_WEAPON(45), // Currently only used by MML - F_PROTO_WEAPON(46), // Currently only used by MML - F_TANK_WEAPON(47), - F_INFANTRY_ATTACK(48), - F_INF_BURST(49), - F_INF_AA(50), - F_INF_NONPENETRATING(51), - F_INF_POINT_BLANK(52), - F_INF_SUPPORT(53), - F_INF_ENCUMBER(54), - F_INF_ARCHAIC(55), - F_INF_CLIMBINGCLAWS(63), // TODO Add game rules IO pg 84 - F_C3MBS(56), // C3 Master Booster System - F_MASS_DRIVER(58), // Naval Mass Drivers - F_CWS(59), - F_MEK_MORTAR(60), - F_BOMB_WEAPON(61), // Weapon required to make a bomb type function - F_BA_INDIVIDUAL(62), - F_PDBAY(64), // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag - F_AMSBAY(65), // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag - F_LARGEMISSILE(66), // Thunderbolt and similar large missiles, for use with AMS resolution - F_HYPER(67), // Hyper-Laser - F_DOUBLE_ONESHOT(68), // Fusillade works like a one-shot weapon but has a second round. - F_ER_FLAMER(69), // ER flamers do half damage in heat mode - F_ARTEMIS_COMPATIBLE(70), // Missile weapon that can be linked to an Artemis fire control system - F_MORTARTYPE_INDIRECT(71), // This flag is used by mortar-type weapons that allow indirect fire without a spotter and/or with LOS. - F_TSEMP(57), // Used for TSEMP Weapons. - F_REPEATING(72); +public enum WeaponTypeFlag implements EquipmentFlag { + // Skill type flags + F_BALLISTIC, // for Gunnery/Ballistic + F_ENERGY, // for Gunnery/Energy + F_MISSILE, // for Gunnery/Missile - private final int flagIndex; + // Weapon property flags + F_ARTILLERY, + F_ARTEMIS_COMPATIBLE, // Missile weapon that can be linked to an Artemis fire control system + F_AUTO_TARGET, // for weapons that target Automatically + F_BA_INDIVIDUAL, + F_BURST_FIRE, // Full Damage vs. Infantry + F_DIRECT_FIRE, // marks any weapon affected by a targeting computer + F_DOUBLE_ONESHOT, // Fusillade works like a one-shot weapon but has a second round. + F_EXTINGUISHER, // fire Extinguisher + F_HEATASDICE, // Variable heat, heat is listed in dice, not points + F_INFANTRY_ONLY, // may only target Infantry + F_MISSILE_HITS, // use missile rules for # of hits + F_MORTARTYPE_INDIRECT, // This flag is used by mortar-type weapons that allow indirect fire without a spotter and/or with LOS. + F_NO_FIRES, // can not start fires + F_NO_AIM, + F_ONESHOT, + F_SOLO_ATTACK, // must be only weapon attacking + F_PROTOTYPE, // War of 3039 prototypes + F_REPEATING, - WeaponTypeFlag(int flagIndex) { - assert flagIndex >= 0; - this.flagIndex = flagIndex; - } + // firestarters + F_INCENDIARY_NEEDLES, // fires + F_INFERNO, // Inferno weapon + F_PLASMA, // fires + + // Special behaviors + F_TAG, + F_C3M, // C3 Master with Target Acquisition gear + F_C3MBS, // C3 Master Booster System + + // Weapon classes + F_ANTI_SHIP, // Anti-ship missiles + F_B_POD, + F_BOMBAST_LASER, + F_HYPER, // Hyper-Laser + F_LASER, + F_LARGEMISSILE, // Thunderbolt and similar large missiles, for use with AMS resolution + F_ER_FLAMER, // ER flamers do half damage in heat mode + F_FLAMER, + F_M_POD, + F_MEK_MORTAR, + F_MG, // MGL for rapid fire setup + F_MGA, // Machine Gun Array + F_PLASMA_MFUK, // Plasma Rifle + F_PPC, + F_PULSE, + F_TASER, + F_TSEMP, // Used for TSEMP Weapons. + F_VGL, + + // Bomb types + F_ALT_BOMB, + F_BOMB_WEAPON, // Weapon required to make a bomb type function + F_DIVE_BOMB, + F_SPACE_BOMB, + + // self defense weapons + F_AMS, // AMS + F_CWS, + + // Capital sized self defense + F_AMSBAY, // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag + F_PDBAY, // AMS and Point Defense Bays - Have to work differently from code using the F_AMS flag + + // Capital weapons + F_CRUISE_MISSILE, + F_MASS_DRIVER, // Naval Mass Drivers + + // Flags to restrict chassis that can receive the weapons + F_AERO_WEAPON, // Currently only used by MML + F_INFANTRY, // Infantry caliber weapon, damage based on # of men shooting + F_BA_WEAPON, // Currently only used by MML + F_MEK_WEAPON, // Currently only used by MML + F_PROTO_WEAPON, // Currently only used by MML + F_TANK_WEAPON, + + // Infantry weapon flags + F_INFANTRY_ATTACK, + F_INF_AA, + F_INF_ARCHAIC, + F_INF_BURST, + F_INF_CLIMBINGCLAWS, // TODO Add game rules IO pg 84 + F_INF_ENCUMBER, + F_INF_NONPENETRATING, + F_INF_POINT_BLANK, + F_INF_SUPPORT, + ; @Override public int getFlagIndex() { - return flagIndex; + return this.ordinal(); } } diff --git a/megamek/src/megamek/common/pathfinder/CachedEntityState.java b/megamek/src/megamek/common/pathfinder/CachedEntityState.java index c7e9d517516..1f4a9e83f53 100644 --- a/megamek/src/megamek/common/pathfinder/CachedEntityState.java +++ b/megamek/src/megamek/common/pathfinder/CachedEntityState.java @@ -40,7 +40,7 @@ public class CachedEntityState { private Integer sprintMPWithoutMasc; private Integer jumpMP; private Integer jumpMPWithTerrain; - private Map hasWorkingMisc; + private Map hasWorkingMisc; private Integer torsoJumpJets; private Integer jumpMPNoGravity; private Integer numBreachedLegs; @@ -122,7 +122,7 @@ public int getJumpMPWithTerrain() { return jumpMPWithTerrain; } - public boolean hasWorkingMisc(IndexedFlag flag) { + public boolean hasWorkingMisc(EquipmentFlag flag) { if (!hasWorkingMisc.containsKey(flag)) { hasWorkingMisc.put(flag, backingEntity.hasWorkingMisc(flag)); } diff --git a/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java b/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java index 40b8cc7867e..907e7cb461b 100644 --- a/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java +++ b/megamek/src/megamek/common/verifier/TestAdvancedAerospace.java @@ -710,7 +710,7 @@ public boolean hasIllegalEquipmentCombinations(StringBuffer buff) { Map rightBroad = new HashMap<>(); Map massDriversPerArc = new HashMap<>(); - var typeFlag = MiscType.F_JS_EQUIPMENT; + MiscTypeFlag typeFlag = MiscType.F_JS_EQUIPMENT; if (vessel.hasETypeFlag(Entity.ETYPE_WARSHIP)) { typeFlag = MiscType.F_WS_EQUIPMENT; } else if (vessel.hasETypeFlag(Entity.ETYPE_SPACE_STATION)) { @@ -719,7 +719,7 @@ public boolean hasIllegalEquipmentCombinations(StringBuffer buff) { for (Mounted m : vessel.getEquipment()) { if (m.getType() instanceof MiscType) { if (!m.getType().hasFlag(typeFlag)) { - buff.append("Cannot mount " + m.getType().getName() + "\n"); + buff.append("Cannot mount ").append(m.getType().getName()).append("\n"); illegal = true; } } else if (m.getType() instanceof WeaponType) { diff --git a/megamek/src/megamek/common/verifier/TestSmallCraft.java b/megamek/src/megamek/common/verifier/TestSmallCraft.java index 3f66622f35a..f564bd30b59 100644 --- a/megamek/src/megamek/common/verifier/TestSmallCraft.java +++ b/megamek/src/megamek/common/verifier/TestSmallCraft.java @@ -584,7 +584,7 @@ public boolean hasIllegalEquipmentCombinations(StringBuffer buff) { Map leftAft = new HashMap<>(); Map rightFwd = new HashMap<>(); Map rightAft = new HashMap<>(); - var typeFlag = smallCraft.hasETypeFlag(Entity.ETYPE_DROPSHIP) + MiscTypeFlag typeFlag = smallCraft.hasETypeFlag(Entity.ETYPE_DROPSHIP) ? MiscType.F_DS_EQUIPMENT : MiscType.F_SC_EQUIPMENT; for (Mounted m : smallCraft.getEquipment()) { diff --git a/megamek/unittests/megamek/client/bot/princess/FireControlTest.java b/megamek/unittests/megamek/client/bot/princess/FireControlTest.java index 79f0079ef72..2f568332f79 100644 --- a/megamek/unittests/megamek/client/bot/princess/FireControlTest.java +++ b/megamek/unittests/megamek/client/bot/princess/FireControlTest.java @@ -428,7 +428,7 @@ void beforeEach() { when(mockAmmoSRM5.getType()).thenReturn(mockAmmoTypeSRM5); when(mockAmmoSRM5.isAmmoUsable()).thenReturn(true); when(mockAmmoTypeLRM5.getMunitionType()).thenReturn(EnumSet.of(AmmoType.Munitions.M_STANDARD)); - when(mockAmmoTypeLRM5.hasFlag(any(IndexedFlag.class))).thenReturn(false); + when(mockAmmoTypeLRM5.hasFlag(any(EquipmentFlag.class))).thenReturn(false); when(mockAmmoTypeLRM5.hasFlag(eq(AmmoType.F_MML_LRM))).thenReturn(true); when(mockAmmoTypeLRM5.getAmmoType()).thenReturn(AmmoType.T_MML); when(mockAmmoLRM5.getType()).thenReturn(mockAmmoTypeLRM5); @@ -520,7 +520,7 @@ void beforeEach() { when(mockWeaponType.getAmmoType()).thenReturn(AmmoType.T_LRM); WeaponType mockEnergyWeaponType = mock(WeaponType.class); when(mockEnergyWeaponType.getAmmoType()).thenReturn(AmmoType.T_NA); - when(mockEnergyWeaponType.hasFlag(any(IndexedFlag.class))).thenReturn(false); + when(mockEnergyWeaponType.hasFlag(any(EquipmentFlag.class))).thenReturn(false); when(mockEnergyWeaponType.hasModeType(anyString())).thenReturn(false); mockPPC = mock(WeaponMounted.class); when(mockPPC.getType()).thenReturn(mockEnergyWeaponType); @@ -2150,7 +2150,7 @@ void testGuessFullAirToGroundPlan() { FiringPlan expected; when(mockShooter.getPosition()).thenReturn(mockShooterCoords); when(mockShooter.isOffBoard()).thenReturn(false); - when(mockShooter.getBombs(any(IndexedFlag.class))).thenReturn(emptyList()); + when(mockShooter.getBombs(any(EquipmentFlag.class))).thenReturn(emptyList()); when(mockTarget.getPosition()).thenReturn(mockTargetCoords); when(mockTarget.isOffBoard()).thenReturn(false); when(mockBoard.contains(eq(mockShooterCoords))).thenReturn(true); From 77450acda37636e80197d83a51f385f24079dcd9 Mon Sep 17 00:00:00 2001 From: Scoppio Date: Sat, 1 Feb 2025 00:59:35 -0300 Subject: [PATCH 4/4] feat: cleaning up a bit more --- megamek/src/megamek/common/AmmoTypeFlag.java | 8 +------- megamek/src/megamek/common/EquipmentBitSet.java | 6 +++--- megamek/src/megamek/common/EquipmentFlag.java | 3 +-- megamek/src/megamek/common/MiscTypeFlag.java | 8 -------- megamek/src/megamek/common/WeaponTypeFlag.java | 7 ------- 5 files changed, 5 insertions(+), 27 deletions(-) diff --git a/megamek/src/megamek/common/AmmoTypeFlag.java b/megamek/src/megamek/common/AmmoTypeFlag.java index 0648befddbf..e60c0eea1c9 100644 --- a/megamek/src/megamek/common/AmmoTypeFlag.java +++ b/megamek/src/megamek/common/AmmoTypeFlag.java @@ -47,12 +47,6 @@ public enum AmmoTypeFlag implements EquipmentFlag { F_NUCLEAR, // Nuclear missile F_SANTA_ANNA, // Nuke Santa Anna Missile - F_PEACEMAKER; // Nuke Peacemaker Missile - - - @Override - public int getFlagIndex() { - return this.ordinal(); - } + F_PEACEMAKER, // Nuke Peacemaker Missile } diff --git a/megamek/src/megamek/common/EquipmentBitSet.java b/megamek/src/megamek/common/EquipmentBitSet.java index b4c637d085b..9d74bd9f4a9 100644 --- a/megamek/src/megamek/common/EquipmentBitSet.java +++ b/megamek/src/megamek/common/EquipmentBitSet.java @@ -50,7 +50,7 @@ public EquipmentBitSet(EquipmentBitSet other) { * @return true if the flag is set in the EquipmentBitSet */ public boolean get(EquipmentFlag flag) { - return bitSet.get(flag.getFlagIndex()); + return bitSet.get(flag.ordinal()); } public boolean contains(EquipmentBitSet other) { @@ -64,7 +64,7 @@ public boolean contains(EquipmentBitSet other) { * @param flag the flag to clear */ public void clear(EquipmentFlag flag) { - bitSet.clear(flag.getFlagIndex()); + bitSet.clear(flag.ordinal()); } /** @@ -79,7 +79,7 @@ public void clear() { * @param flag the flag to set */ public void set(EquipmentFlag flag) { - bitSet.set(flag.getFlagIndex()); + bitSet.set(flag.ordinal()); } diff --git a/megamek/src/megamek/common/EquipmentFlag.java b/megamek/src/megamek/common/EquipmentFlag.java index 150b961701c..824ad187f0e 100644 --- a/megamek/src/megamek/common/EquipmentFlag.java +++ b/megamek/src/megamek/common/EquipmentFlag.java @@ -24,10 +24,9 @@ public interface EquipmentFlag { /** * Returns the index of the flag in the bitset - * - Future improvements, return ordinal instead of arbitrary index * @return the index of the flag in the bitset */ - int getFlagIndex(); + int ordinal(); /** * Converts this flag to an {@link EquipmentBitSet}. diff --git a/megamek/src/megamek/common/MiscTypeFlag.java b/megamek/src/megamek/common/MiscTypeFlag.java index 325ed87bb89..69122394078 100644 --- a/megamek/src/megamek/common/MiscTypeFlag.java +++ b/megamek/src/megamek/common/MiscTypeFlag.java @@ -298,12 +298,4 @@ public enum MiscTypeFlag implements EquipmentFlag { F_HYPERSPECTRAL_IMAGER, // TODO: add game rules for the following imagers/radars, construction data only F_INFRARED_IMAGER, // TODO: add game rules for the following imagers/radars, construction data only F_LOOKDOWN_RADAR, // TODO: add game rules for the following imagers/radars, construction data only - ; - - @Override - public int getFlagIndex() { - return this.ordinal(); - } - - } diff --git a/megamek/src/megamek/common/WeaponTypeFlag.java b/megamek/src/megamek/common/WeaponTypeFlag.java index ecc45421de3..0473bfd0987 100644 --- a/megamek/src/megamek/common/WeaponTypeFlag.java +++ b/megamek/src/megamek/common/WeaponTypeFlag.java @@ -112,11 +112,4 @@ public enum WeaponTypeFlag implements EquipmentFlag { F_INF_NONPENETRATING, F_INF_POINT_BLANK, F_INF_SUPPORT, - ; - - @Override - public int getFlagIndex() { - return this.ordinal(); - } - }