diff --git a/megamek/src/megamek/client/ui/swing/MapMenu.java b/megamek/src/megamek/client/ui/swing/MapMenu.java index 366106147d1..533a2b0131f 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(EquipmentFlag 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..e60c0eea1c9 --- /dev/null +++ b/megamek/src/megamek/common/AmmoTypeFlag.java @@ -0,0 +1,52 @@ +/* + * 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; + +/** + * 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 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 + +} diff --git a/megamek/src/megamek/common/Entity.java b/megamek/src/megamek/common/Entity.java index fa40dabd88d..3d8948758e9 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(EquipmentFlag 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(EquipmentFlag 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(EquipmentFlag 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(EquipmentFlag flag) { return miscList.stream().anyMatch(misc -> misc.getType().hasFlag(flag)); } - public List getMiscEquipment(BigInteger flag) { + public List getMiscEquipment(EquipmentFlag 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(EquipmentFlag flag) { return countWorkingMisc(flag, -1); } - public int countWorkingMisc(BigInteger 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) @@ -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(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 new file mode 100644 index 00000000000..9d74bd9f4a9 --- /dev/null +++ b/megamek/src/megamek/common/EquipmentBitSet.java @@ -0,0 +1,148 @@ +/* + * 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; +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 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); + } + + /** + * 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(EquipmentFlag flag) { + return bitSet.get(flag.ordinal()); + } + + 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(EquipmentFlag flag) { + bitSet.clear(flag.ordinal()); + } + + /** + * 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(EquipmentFlag flag) { + bitSet.set(flag.ordinal()); + } + + + /** + * 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(EquipmentFlag 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(EquipmentFlag 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(EquipmentFlag 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 instanceof EquipmentBitSet that) { + return Objects.equals(bitSet, that.bitSet); + } + + return false; + } + + @Override + public int hashCode() { + return Objects.hashCode(bitSet); + } +} diff --git a/megamek/src/megamek/common/EquipmentFlag.java b/megamek/src/megamek/common/EquipmentFlag.java new file mode 100644 index 00000000000..824ad187f0e --- /dev/null +++ b/megamek/src/megamek/common/EquipmentFlag.java @@ -0,0 +1,38 @@ +/* + * 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 EquipmentFlag { + /** + * Returns the index of the flag in the bitset + * @return the index of the flag in the bitset + */ + int ordinal(); + + /** + * 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/EquipmentType.java b/megamek/src/megamek/common/EquipmentType.java index da38aa2f65e..0058f565fcc 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(EquipmentFlag 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/Mek.java b/megamek/src/megamek/common/Mek.java index 9eb4ee92477..36e1717d871 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, EquipmentFlag 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, 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/MiscType.java b/megamek/src/megamek/common/MiscType.java index bf867b1ad93..a1337ff9867 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..69122394078 --- /dev/null +++ b/megamek/src/megamek/common/MiscTypeFlag.java @@ -0,0 +1,301 @@ +/* + * 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; + +/** + * 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 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 +} diff --git a/megamek/src/megamek/common/WeaponType.java b/megamek/src/megamek/common/WeaponType.java index ae5584a8059..3728316c70c 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,138 @@ 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); - - // 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_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; + + 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..0473bfd0987 --- /dev/null +++ b/megamek/src/megamek/common/WeaponTypeFlag.java @@ -0,0 +1,115 @@ +/* + * 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; + + +/** + * 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 EquipmentFlag { + // Skill type flags + F_BALLISTIC, // for Gunnery/Ballistic + F_ENERGY, // for Gunnery/Energy + F_MISSILE, // for Gunnery/Missile + + // 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, + + // 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, +} diff --git a/megamek/src/megamek/common/pathfinder/CachedEntityState.java b/megamek/src/megamek/common/pathfinder/CachedEntityState.java index 34772be8dc4..1f4a9e83f53 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(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 ebfb0b54f4a..907e7cb461b 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; + 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)) { @@ -720,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 084ff1f2d0c..f564bd30b59 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) + MiscTypeFlag 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 122ee25cf5b..a0129308657 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; @@ -437,7 +436,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(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); @@ -529,7 +528,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(EquipmentFlag.class))).thenReturn(false); when(mockEnergyWeaponType.hasModeType(anyString())).thenReturn(false); mockPPC = mock(WeaponMounted.class); when(mockPPC.getType()).thenReturn(mockEnergyWeaponType); @@ -2204,7 +2203,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(EquipmentFlag.class))).thenReturn(emptyList()); when(mockTarget.getPosition()).thenReturn(mockTargetCoords); when(mockTarget.isOffBoard()).thenReturn(false); when(mockBoard.contains(eq(mockShooterCoords))).thenReturn(true);