0.96可用的mod迁移到0.97时出错

齐格隆冬强 发表于 2025-4-24 20:55:58

22434 ERROR com.fs.starfarer.combat.CombatMain- java.lang.RuntimeException: Error loading
java.lang.RuntimeException: Error loading
at com.fs.starfarer.loading.scripts.ScriptStore$3.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)
Caused by: java.lang.ClassFormatError: Inconsistent constant value type in class file data/scripts/hullmods/missile_reloadMyS
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at org.codehaus.janino.JavaSourceClassLoader.defineBytecode(JavaSourceClassLoader.java:244)
at org.codehaus.janino.JavaSourceClassLoader.findClass(JavaSourceClassLoader.java:194)
at java.lang.ClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
... 2 more

看着似乎是第三行引用的global类文件错误，但是把游戏自带的api解开看了下global类，没有发现问题。附上出错的这部分内容
package data.scripts.hullmods;

import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.combat.BaseHullMod;
import com.fs.starfarer.api.combat.CombatEngineAPI;
import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.combat.WeaponAPI;
import com.fs.starfarer.api.combat.ShipAPI.HullSize;
import com.fs.starfarer.api.combat.WeaponAPI.WeaponType;
import com.fs.starfarer.api.combat.WeaponAPI.WeaponSize;
import com.fs.starfarer.api.util.IntervalUtil;
import com.fs.starfarer.api.combat.MutableStat;
import com.fs.starfarer.api.ui.TooltipMakerAPI;
import com.fs.starfarer.api.util.Misc;
import java.util.Map;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import com.fs.starfarer.api.impl.campaign.ids.Stats;
import data.scripts.util.MagicIncompatibleHullmods;

import data.scripts.util.MagicUI;
import java.awt.Color;
//import com.fs.starfarer.api.FluxTrackerAPI;

import com.fs.starfarer.api.fleet.FleetMemberAPI;
import com.fs.starfarer.api.characters.MutableCharacterStatsAPI;
import com.fs.starfarer.api.loading.WeaponSpecAPI;
import com.fs.starfarer.api.combat.MissileAPI;
import com.fs.starfarer.api.combat.WeaponAPI.AIHints;

import java.util.LinkedHashSet;
import java.util.ArrayList;
import java.util.List;
import com.fs.starfarer.api.ui.Alignment;
import java.io.IOException;
//import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class missile_reloadMyS extends BaseHullMod {
public float OP_Pct = 0f; // 装配点加值
public int OP_Bonus = 0; // 装配点百分比加成
/*
public static final String SETTINGS_FILE = "MissileReload_Setting.JSON";
private void loadSettings() throws IOException, JSONException
{
   JSONObject settings = Global.getSettings().loadJSON(SETTINGS_FILE);
   OP_Pct = Float.valueOf(settings.getString("OP_Pct2"));
   OP_Bonus = Integer.valueOf(settings.getString("OP_Bonus2"));
}
*/
public static final float TURN_PENALTY = 10f;
private int usedOP;
private int totalOP;
private int unusedOP = 0;
private int opRequiredToInstall = 0;
private int opRequiredToInstallExtra =0;
private float FuelTankPen =0f;
private float HullPen = 5f;
private static final float LCostPen = 20f;
private static final float MCostPen = 10f;
private static final float SCostPen = 5f;
private final Set<String> BLOCKED_HULLMODS = new HashSet();
{
   // These hullmods will automatically be removed
   // This prevents unexplained hullmod blocking
   BLOCKED_HULLMODS.add("missile_reload");
   BLOCKED_HULLMODS.add("MHMods_prefabricator");
   BLOCKED_HULLMODS.add("mhmods_reloader");
   BLOCKED_HULLMODS.add("tahlan_scalarautoforge");
   BLOCKED_HULLMODS.add("seven_overcapacity_missile_racks");
   BLOCKED_HULLMODS.add("hhe_MissileReload");
   BLOCKED_HULLMODS.add("apex_ins_missiles");
   BLOCKED_HULLMODS.add("miniature_PeriodicMissileReload");
   BLOCKED_HULLMODS.add("missile_autoloader");
   BLOCKED_HULLMODS.add("vayra_bear_autoforge");
   BLOCKED_HULLMODS.add("fed_missileforge");
   BLOCKED_HULLMODS.add("aEP_MissilePlatform");

   BLOCKED_HULLMODS.add("VEmissleracks");
   BLOCKED_HULLMODS.add("VEmagazines");
}
public static final float IntMin = 50f;//60f // 80f; // 270f; // IntMin = 480 / IntDiv;
public static final float IntMax = 60f;//75f //100f; // 330f; // IntMax = 600 / IntDiv;
public static final float EMagReloadS = 0.25f; //0.50f; //0.33f; //0.25f; //0.20f;
public static final float EMagReloadM = 0.177f; //0.34f; //0.25f; //0.177f; //0.14f;
public static final float EMagReloadL = 0.125f; //0.25f; //0.17f; //0.125f; //0.1f;
public static final float EMagReloadB = 0.1f; //0.2f;
public static final float EFluxCostB = 100f; //200f; //250f; //100f; // 50f; 320f; 600f;
public static final float EFluxCostS = 200f; //400f; //500f; //360f; // 240f; 320f; 600f;
public static final float EFluxCostM = 400f; //800f; //1000f; //720f; // 480f; 640f; 1200f;
public static final float EFluxCostL = 800f; //1600f; //2000f; //1440f; // 960f; 1280f; 2400f;
public static final float FireRate_Bonus = 10f;
public static final float EDmgPct = 5f;

public static String MR_DATA_KEY = "core_reload_data_key";
private static Map eFluxlvl = new HashMap();
private static Map eMagPct = new HashMap();
private static Map eFluxCost = new HashMap();
static {
eFluxlvl.put(HullSize.FRIGATE, 0.65f);
eFluxlvl.put(HullSize.DESTROYER, 0.70f);
eFluxlvl.put(HullSize.CRUISER, 0.75f);
eFluxlvl.put(HullSize.CAPITAL_SHIP, 0.80f);
eMagPct.put(WeaponSize.SMALL,EMagReloadS);
eMagPct.put(WeaponSize.MEDIUM,EMagReloadM);
eMagPct.put(WeaponSize.LARGE,EMagReloadL);
eFluxCost.put(WeaponSize.SMALL,EFluxCostS);
eFluxCost.put(WeaponSize.MEDIUM,EFluxCostM);
eFluxCost.put(WeaponSize.LARGE,EFluxCostL);
}
private static final float FluxlvlS = 0.1f;

private static final float LMissileCostPen = 8;
private static final float MMissileCostPen = 4;
private static final float SMissileCostPen = 2;
private static final float LWeapCostPen = 2f;
private static final float MWeapCostPen = 1f;
private static final float SWeapCostPen = 0f;
private static final float LWeapCostPenS = 4;
private static final float MWeapCostPenS = 2;
private static final float SWeapCostPenS = 1;
public static class AmmoReloadData {
IntervalUtil interval = new IntervalUtil(IntMin, IntMax);
}
public static final float ReloadRate = 10f;
public static final float ReloadRateEx = 20f;

public void applyEffectsAfterShipCreation(ShipAPI ship, String id){
   //blocked hullmods
   for (String tmp : BLOCKED_HULLMODS) {
         if (ship.getVariant().getHullMods().contains(tmp)) {
            MagicIncompatibleHullmods.removeHullmodWithWarning(ship.getVariant(), tmp, "missile_reloadMyS");
         }
   }
}
public void applyEffectsBeforeShipCreation(HullSize hullSize, MutableShipStatsAPI stats, String id) {

float ReloadRateMultMissile = 1f;
float ReloadRateMultBullet = 1f;
float lMissileCost = LMissileCostPen;
float mMissileCost = MMissileCostPen;
float sMissileCost = SMissileCostPen;
float lWeaponCost = LWeapCostPen;
float mWeaponCost = MWeapCostPen;
float sWeaponCost = SWeapCostPen;
ReloadRateMultBullet = 1 + ReloadRate * 0.01f;
ReloadRateMultMissile = 1 + ReloadRate * 0.01f;
float fireRate = FireRate_Bonus;
float turn_Penalty;
turn_Penalty = -TURN_PENALTY;
if (stats.getVariant().getSMods().contains("magazines") || stats.getVariant().getHullSpec().isBuiltInMod("magazines")) {
ReloadRateMultBullet += ReloadRateEx * 0.01f;
}
if (stats.getVariant().getSMods().contains("missleracks") || stats.getVariant().getHullSpec().isBuiltInMod("missleracks")
|| stats.getVariant().getSMods().contains("sex_slowracks") || stats.getVariant().getHullSpec().isBuiltInMod("sex_slowracks")){
ReloadRateMultMissile += ReloadRateEx * 0.01f;
}
if (stats.getVariant().getSMods().contains("missile_reloadMyS")) {
lMissileCost += LWeapCostPenS;
mMissileCost += MWeapCostPenS;
sMissileCost += SWeapCostPenS;
lWeaponCost += LWeapCostPenS;
mWeaponCost += MWeapCostPenS;
sWeaponCost += SWeapCostPenS;
fireRate += FireRate_Bonus;
turn_Penalty = -turn_Penalty/2;
}
if (stats.getVariant().getHullSpec().isBuiltInMod("missile_reloadMyS")) {
lMissileCost = 0f;
mMissileCost = 0f;
sMissileCost = 0f;
lWeaponCost = 0f;
mWeaponCost = 0f;
sWeaponCost = 0f;
stats.getHullBonus().modifyPercent(id, 0f);
fireRate += FireRate_Bonus;
turn_Penalty = 0f;
}
stats.getHullBonus().modifyPercent(id, -HullPen);
   stats.getDynamic().getMod(Stats.LARGE_MISSILE_MOD).modifyFlat(id, lMissileCost);
   stats.getDynamic().getMod(Stats.MEDIUM_MISSILE_MOD).modifyFlat(id, mMissileCost);
stats.getDynamic().getMod(Stats.SMALL_MISSILE_MOD).modifyFlat(id, sMissileCost);

   stats.getDynamic().getMod(Stats.LARGE_PD_MOD).modifyFlat(id, -lWeaponCost);
   stats.getDynamic().getMod(Stats.MEDIUM_PD_MOD).modifyFlat(id, -mWeaponCost);
stats.getDynamic().getMod(Stats.SMALL_PD_MOD).modifyFlat(id, -sWeaponCost);

stats.getDynamic().getMod(Stats.LARGE_BEAM_MOD).modifyFlat(id, lWeaponCost);
stats.getDynamic().getMod(Stats.MEDIUM_BEAM_MOD).modifyFlat(id, mWeaponCost);
stats.getDynamic().getMod(Stats.SMALL_BEAM_MOD).modifyFlat(id, sWeaponCost);

stats.getDynamic().getMod(Stats.LARGE_BALLISTIC_MOD).modifyFlat(id, lWeaponCost ); // OP Cost
stats.getDynamic().getMod(Stats.MEDIUM_BALLISTIC_MOD).modifyFlat(id, mWeaponCost); // OP Cost
stats.getDynamic().getMod(Stats.SMALL_BALLISTIC_MOD).modifyFlat(id, sWeaponCost); // OP Cost

stats.getDynamic().getMod(Stats.LARGE_ENERGY_MOD).modifyFlat(id, lWeaponCost);
stats.getDynamic().getMod(Stats.MEDIUM_ENERGY_MOD).modifyFlat(id, mWeaponCost);
stats.getDynamic().getMod(Stats.SMALL_ENERGY_MOD).modifyFlat(id, sWeaponCost);

stats.getBallisticAmmoRegenMult().modifyMult(id, ReloadRateMultBullet );
stats.getEnergyAmmoRegenMult().modifyMult(id, ReloadRateMultBullet );
stats.getMissileAmmoRegenMult().modifyMult(id, ReloadRateMultMissile );

stats.getMissileAmmoBonus().modifyMult(id, 0.5f);
stats.getBallisticAmmoBonus().modifyMult(id, 0.5f);
stats.getEnergyAmmoBonus().modifyMult(id, 0.5f);
/* 射速增加 */
stats.getMissileRoFMult().modifyPercent(id,fireRate);
stats.getBallisticRoFMult().modifyPercent(id,fireRate);
stats.getEnergyRoFMult().modifyPercent(id,fireRate);
stats.getWeaponTurnRateBonus().modifyPercent(id, turn_Penalty);
stats.getBeamWeaponTurnRateBonus().modifyPercent(id, turn_Penalty);
}

public void addPostDescriptionSection(TooltipMakerAPI tooltip, ShipAPI.HullSize hullSize, ShipAPI ship, float width, boolean isForModSpec) {
Color colorC = Misc.getGrayColor();
Color colorH = Misc.getHighlightColor();
Color colorP = Misc.getPositiveHighlightColor();
Color colorN = Misc.getNegativeHighlightColor();
float pad = 3f;
float opad = 10f;
String StrOP = ""; //" OP+" + (int)OP_Bonus + ",+" + (int)OP_Pct + "%";
String S0 = "安装微型供弹模块破坏了舰船结构的完整性，结构减少" + (int)HullPen + "%。";
String s01 = "弹药工厂需要额外装配点安装适配设备用于生产并装填弹药"
+ " (每大型/中型/小型导弹所需装配点增加 " + (int)(LMissileCostPen) + "/" + (int)(MMissileCostPen) + "/" + (int)(SMissileCostPen)
+"，" + " 每大型/中型/小型武器所需装配点增加 " + (int)(LWeapCostPen) + "/" + (int)(MWeapCostPen) + "/" + (int)(SWeapCostPen)
+ ")。";
String s01b = "本舰为微型供弹模块设计了专门配套设备，导弹武器无需额外装配点。 ";
String s01c = "微型供弹模块需要额外装配点安装适配设备用于生产并装填弹药 (每大型/中型/小型导弹所需装配点增加 " + (int)(LWeapCostPenS+LMissileCostPen) + "/" + (int)(MWeapCostPenS+MMissileCostPen) + "/" + (int)(SWeapCostPenS+SMissileCostPen) + ") "
+ "，" + " (每大型/中型/小型武器所需装配点增加 " + (int)(LWeapCostPenS+LWeapCostPen) + "/" + (int)(MWeapCostPenS+MWeapCostPen) + "/" + (int)(SWeapCostPenS+SWeapCostPen) + ") "
+ "。";
String s03 = "生产设备侵占空间，导弹、实弹、能量武器备弹量减半。 "; // "生产设备侵占空间，导弹备弹量减半，实弹、能量武器备弹减少50%。 ";
String S8 = "自动装填导弹再装填速度增加" ;
String S9 = "自动装填实弹/能量武器再装填速度增加";
float FluxLvl;
FluxLvl = (Float)eFluxlvl.get(hullSize) * 100f;
List<String> weaponName = new ArrayList<String>();
List<Integer> weaponFlux = new ArrayList<Integer>();
List<Integer> weaponAmmo = new ArrayList<Integer>();
List<Integer> weaponLoad = new ArrayList<Integer>();
List<String> weaponNameLess = new ArrayList<String>();
List<Integer> weaponAmmoLess = new ArrayList<Integer>();
List<Integer> weaponAmmoReq = new ArrayList<Integer>();
int iAmmoAdd;
float fAmmoAddTemp;
int iAmmo=0;
int iAuto=0;
int iFluxAdd=0;
int iFluxAddTemp;
int iAmmoMax=0;
boolean bReload=false;
boolean bReq=false;
Set<String> seen = new LinkedHashSet<String>();
for (WeaponAPI w : ship.getAllWeapons()) {
int[] LoadAmmoFlux = {0, 0};
float fMult = 1f;
if (!(ship.getVariant().hasHullMod("missile_reloadMyS"))) { fMult = 0.5f; }
fAmmoAddTemp = AutoLoadAmmoFlux(w, LoadAmmoFlux, fMult);
if (fAmmoAddTemp<=0) continue;
iAmmoMax = LoadAmmoFlux;
iFluxAddTemp = LoadAmmoFlux;
String id = w.getId();
iAmmoAdd = (int)fAmmoAddTemp;
if (iAmmoAdd>=1) {
iFluxAdd += iFluxAddTemp; // 计算消耗的总flux
if (seen.contains(id)) continue; // 已存在同类武器，跳过以下步骤
bReload = true;
weaponName.add(w.getDisplayName());
weaponLoad.add(iAmmoAdd);
weaponAmmo.add(iAmmoMax);
weaponFlux.add(iFluxAddTemp);
} else {
if (seen.contains(id)) continue; // 已存在同类武器，跳过以下步骤
bReq = true;
int iAmmoReq = (int)(1/EMagReloadB);
if (w.getType() == WeaponType.MISSILE) iAmmoReq = (int)(1/(Float)eMagPct.get(w.getSize()));
weaponNameLess.add(w.getDisplayName());
weaponAmmoLess.add(iAmmoMax);
weaponAmmoReq.add(iAmmoReq);
}
seen.add(id);
}
tooltip.addSectionHeading("注意"+StrOP, Alignment.MID, opad);
if (bReload || bReq) {
tooltip.addPara("%s", 10f, colorN, colorN, S0 + "\n" + s03);
} else {
tooltip.addPara("%s", 10f, colorN, colorN, S0);
}
String sFluxLvl = "根据辐能耗散安全控制协议当本舰处于过载、主动散辐或辐能水平大于 " + String.valueOf((int)FluxLvl) + "％时暂停生产弹药。";
String sFluxLvlS = "当本舰处于过载、主动散辐或辐能水平大于 " + String.valueOf((int)(FluxLvl+FluxlvlS*100)) + "％时暂停生产弹药。";
String sFireRate = "实弹/导弹武器射速增加 ";
String sDamage = "能量武器杀伤增加";
String sTurnRate = "炮塔转向速度减少 ";
if (isForModSpec) {
tooltip.addPara( sFluxLvl + "\n%s", 10f, colorH, colorC, "S-mod: " + sFluxLvlS );
tooltip.addPara( sFireRate + (int)FireRate_Bonus + "％，" + sDamage + (int)EDmgPct + "％。" + " \n%s", 10f, colorP, colorN, sTurnRate+ (int)TURN_PENALTY + "％。");
tooltip.addPara( "S-mod: " + sFireRate + (int)FireRate_Bonus*2 + "％，" + sDamage + (int)EDmgPct*2 + + "％。" + " \n%s", 10f, colorC, colorC, sTurnRate + (int)TURN_PENALTY/2 + "％。" );
tooltip.addPara( s01 + "\n%s", 10f, colorN, colorC, "S-mod Penalty: " + s01c );
} else if (ship.getVariant().getSMods().contains("missile_reloadMyS")) {
tooltip.addPara( "S-mod: %s", 10f, colorH, colorH, sFluxLvlS);
tooltip.addPara(sFireRate + (int)FireRate_Bonus*2 + "％，" + sDamage + (int)EDmgPct*2 + "％。" + " \n%s", 10f, colorP, colorN, sTurnRate + (int)TURN_PENALTY/2 + "％。" );
tooltip.addPara( "%s", 10f, colorN, colorN, "S-mod Penalty: " + s01c);
} else if (ship.getHullSpec().isBuiltInMod("missile_reloadMyS")) {
tooltip.addPara( "Built-In: %s", 10f, colorH, colorH, sFluxLvlS);
tooltip.addPara( sFireRate + (int)FireRate_Bonus*2 + "％，" + sDamage + (int)EDmgPct*2 + "％。" + " \n%s", 10f, colorP, colorN, "");
tooltip.addPara( "%s", 10f, colorP, colorP, "Built-In Bonus: " + s01b);
} else if (!isForModSpec) {
tooltip.addPara( sFluxLvl + "\n%s", 10f, colorN, colorC, "S-mod: " + sFluxLvlS );
tooltip.addPara( sFireRate + (int)FireRate_Bonus + "％，" + sDamage + (int)EDmgPct + "％。" + " \n%s", 10f, colorP, colorN, sTurnRate+ (int)TURN_PENALTY + "％。");
tooltip.addPara( "S-mod: " + sFireRate + (int)FireRate_Bonus*2 + "％，" + sDamage + (int)EDmgPct*2 + + "％。" + " \n%s", 10f, colorC, colorC, sTurnRate + (int)TURN_PENALTY/2 + "％。" );
tooltip.addPara( s01 + "\n%s", 10f, colorN, colorC, "S-mod Penalty: " + s01c );
}
if (isForModSpec) {
tooltip.addPara("%s", 10f, colorP, colorH, S8 + (int)ReloadRate + "%。" );
tooltip.addPara("配合 S插件或内置插件 \"Expanded Missile Racks\" 与 \"Integrated Missile Racks\": %s", 10f, colorC, colorC, S8 + (int)(ReloadRate+ReloadRateEx) + "%。");
} else if (ship.getVariant().getSMods().contains("missleracks") || ship.getHullSpec().isBuiltInMod("missleracks") || ship.getVariant().getSMods().contains("sex_slowracks") || ship.getHullSpec().isBuiltInMod("sex_slowracks")) {
tooltip.addPara("配合 S插件或内置插件 \"Expanded Missile Racks\" 与 \"Integrated Missile Racks\": %s", 10f, colorH, colorP, S8 + (int)(ReloadRate+ReloadRateEx) + "%。");
} else if (!isForModSpec) {
tooltip.addPara("%s", 10f, colorP, colorH, S8 + (int)ReloadRate + "%。" );
tooltip.addPara("配合 S插件或内置插件 \"Expanded Missile Racks\" 与 \"Integrated Missile Racks\": %s", 10f, colorC, colorC, S8 + (int)(ReloadRate+ReloadRateEx) + "%。");
}
if (isForModSpec) {
tooltip.addPara("%s", 10f, colorP, colorH, S9 + (int)ReloadRate + "%。" );
tooltip.addPara("配合 S插件或内置插件 \"Expanded Magazines\" : %s", 10f, colorC, colorC, S9 + (int)(ReloadRate+ReloadRateEx) + "%。");
} else if (ship.getVariant().getSMods().contains("magazines") || ship.getHullSpec().isBuiltInMod("magazines")) {
tooltip.addPara("配合 S插件或内置插件 \"Expanded Magazines\" : %s", 10f, colorH, colorP, S9 + (int)(ReloadRate+ReloadRateEx) + "%。");
} else if (!isForModSpec) {
tooltip.addPara("%s", 10f, colorP, colorH, S9 + (int)ReloadRate + "%。" );
tooltip.addPara("配合 S插件或内置插件 \"Expanded Magazines\" : %s", 10f, colorC, colorC, S9 + (int)(ReloadRate+ReloadRateEx) + "%。");
}

tooltip.setBgAlpha(0.9f);
if (bReload) {
tooltip.addSectionHeading("装填耗时" + (int)IntMin + "-" + (int)IntMax +"秒", Alignment.MID, opad);
float fluxW = 45f;
float reloadW = 45f;
float AmmoW = 45f;
float NameW = width - fluxW - reloadW - AmmoW - 4f;
tooltip.beginTable(Misc.getBasePlayerColor(), Misc.getDarkPlayerColor(), Misc.getBrightPlayerColor(),
   20f, true, true,
   new Object [] { "Flux", fluxW, "Load", reloadW, "Ammo", AmmoW, "Weapon", NameW});
for (int i;i<weaponName.size() ;i++ )
{
tooltip.addRow(Alignment.MID, colorN, String.valueOf(weaponFlux.get(i)),
   Alignment.MID, colorP, String.valueOf(weaponLoad.get(i)),
   Alignment.MID, colorH, String.valueOf(weaponAmmo.get(i)),
   Alignment.LMID, colorH, weaponName.get(i));
}
tooltip.addTable("", 0, opad);
tooltip.addPara("弹舱未满时开始生产弹药，完全装弹最多产生 %s 辐能。", 10f, colorH, colorN, String.valueOf(iFluxAdd));
}
if (bReq) {
tooltip.addSectionHeading("弹舱空间不足", Alignment.MID, opad);
float AmmoW = 45f;
float ReqW = 45f;
float MemoW = 45f;
float NameW = width - AmmoW - ReqW - MemoW - 4f;
tooltip.beginTable(Misc.getBasePlayerColor(), Misc.getDarkPlayerColor(), Misc.getBrightPlayerColor(),
   20f, true, true,
   new Object [] {"", MemoW, "Req", ReqW, "Ammo", AmmoW, "Weapon", NameW});
for (int i;i<weaponNameLess.size() ;i++ )
{
tooltip.addRow(
   Alignment.MID, colorN, "",
   Alignment.MID, colorN, String.valueOf(weaponAmmoReq.get(i)),
   Alignment.MID, colorH, String.valueOf(weaponAmmoLess.get(i)),
   Alignment.LMID, colorH, weaponNameLess.get(i));
}
tooltip.addTable("", 0, opad);
}
if (!(bReload || bReq)) {
tooltip.addSectionHeading("无需装填", Alignment.MID, opad);
}

tooltip.addSectionHeading("警告", Alignment.MID, opad);
tooltip.addPara("%s", 10f, colorN, colorN, "不能与其他自动装填船插一起工作，可能会引起系统致命冲突。" );
}

public static float AutoLoadAmmoFlux(WeaponAPI w, int[] LoadAmmoFlux, float m) {
if (w == null) return 0;
if (w.isDecorative()) return 0;
if (w.getSlot() != null && w.getSlot().isSystemSlot()) return 0;
if (!w.usesAmmo()) return 0;
if (w.getAmmoPerSecond()>0) return -1;
int iMaxAmmo;
float fAddAmmo;
iMaxAmmo = w.getMaxAmmo();
fAddAmmo = (int)(EMagReloadB * iMaxAmmo * m);
if (w.getType() == WeaponType.MISSILE) {
fAddAmmo = (Float)eMagPct.get(w.getSize()) * iMaxAmmo * m;
}
LoadAmmoFlux = (int)(iMaxAmmo * m);
float fAddFlux;
fAddFlux = EFluxCostB;
if (w.getType() == WeaponType.MISSILE) {
fAddFlux = (Float)eFluxCost.get(w.getSize());
}
LoadAmmoFlux = (int)fAddFlux;
return fAddAmmo;
}

public String getDescriptionParam(int index, HullSize hullSize) {
String s2 = "因弹药工厂装填时间太长，工程师们对其进行了小型化改进。减少了装填时间和装配需求，副作用是弹药舱与装弹量减半。"; //"RPG分子的杰作，为了纠正能生产战机却无法生产导弹的世界bug而诞生";
String s5 = "";
String s00 = "";
String s01 = "";
if (index == 0) {
return "\n" + s00 + s01 + s2;
}
if (index == 1) {
return s5;
}
return null;
}

@Override
public void advanceInCombat(ShipAPI ship, float amount) {
super.advanceInCombat(ship, amount);
int iAddAmmo ;
int iSetAmmo ;
int iMaxAmmo ;
float fCurrFlux;
float fAddFlux;
float FluxLvlOver ;

if (!ship.isAlive()) return;

CombatEngineAPI engine = Global.getCombatEngine();

String key = MR_DATA_KEY + "_" + ship.getId();
AmmoReloadData data = (AmmoReloadData) engine.getCustomData().get(key);
if (data == null) {
data = new AmmoReloadData();
engine.getCustomData().put(key, data);
}

boolean bReloadSystemWork = false;
for (WeaponAPI w : ship.getAllWeapons()) {

iMaxAmmo = (int)w.getMaxAmmo();
iAddAmmo = (int)(EMagReloadB * iMaxAmmo);
if (w.getType() == WeaponType.MISSILE) {
iAddAmmo = (int)((Float)eMagPct.get(w.getSize()) * iMaxAmmo);
}
if ((w.usesAmmo() && w.getAmmo() < w.getMaxAmmo() && w.getAmmoTracker().getAmmoPerSecond() == 0) && (iAddAmmo >= 1)) {
bReloadSystemWork = true;
}
}
if (bReloadSystemWork) {
MagicUI.drawSystemBar(ship, MagicUI.REDCOLOR, data.interval.getElapsed()/data.interval.getMaxInterval(), 0);
FluxLvlOver = (Float) eFluxlvl.get(ship.getHullSize());
if (ship.getVariant().getSMods().contains("missile_reloadMy") || ship.getVariant().getHullSpec().isBuiltInMod("missile_reloadMy")) { FluxLvlOver += FluxlvlS; }
if (!ship.getFluxTracker().isOverloadedOrVenting() && ship.getFluxLevel() <= (Float)FluxLvlOver) {
data.interval.advance(amount);
if (data.interval.intervalElapsed()) {
for (WeaponAPI w : ship.getAllWeapons()) {

fAddFlux = EFluxCostB;
iMaxAmmo = (int)w.getMaxAmmo();
iAddAmmo = (int)(EMagReloadB * iMaxAmmo);
if (w.getType() == WeaponType.MISSILE) {
fAddFlux = (Float)eFluxCost.get(w.getSize());
iAddAmmo = (int)((Float)eMagPct.get(w.getSize()) * iMaxAmmo);
}

if ((w.usesAmmo() && w.getAmmo() < w.getMaxAmmo() && w.getAmmoTracker().getAmmoPerSecond() == 0) && (iAddAmmo >= 1)) {
iSetAmmo = iAddAmmo + (int)w.getAmmo();
if (iSetAmmo > iMaxAmmo) { iSetAmmo = iMaxAmmo; }
w.setAmmo(iSetAmmo);
               ship.getFluxTracker().increaseFlux( fAddFlux , true);
if (ship.getOwner() == 0) {
engine.addFloatingText(w.getLocation(), "+" + (iAddAmmo) + "(" + (int)iSetAmmo + "/" + (int)iMaxAmmo + ")", 25, Color.GREEN, ship, 0f, 0f); //+ "" // + "\n" + w.getDisplayName()
}
/*
else {
engine.addFloatingText(w.getLocation(), "+" + (iAddAmmo) + "\n" + w.getDisplayName(), 25, Color.GREEN, ship, 0f, 0f);
}
*/
}
}
}
}
} else {
data.interval.setElapsed(0f);
}
}
@Override
public boolean affectsOPCosts() {
return true;
}
private boolean enoughOPToInstall(ShipAPI ship) {
   if ((ship == null) || (ship.getVariant() == null)) {
         return true;
   }
   if (ship.getVariant().hasHullMod(spec.getId())) {
         return true;
   }

   FleetMemberAPI member = ship.getFleetMember();
   MutableCharacterStatsAPI stats = null;
   if ((member != null) && (member.getFleetCommanderForStats() != null)) {
         stats = member.getFleetCommanderForStats().getFleetCommanderStats();
   }

totalOP = 0;
opRequiredToInstallExtra = 0;
for (WeaponAPI w : ship.getAllWeapons()) {
if(!w.getSpec().getAIHints().contains(AIHints.PD)) {
if (w.getType() == WeaponType.MISSILE) {
if (w.getSize() == WeaponSize.SMALL) {
opRequiredToInstallExtra += SMissileCostPen;
}
if (w.getSize() == WeaponSize.MEDIUM) {
opRequiredToInstallExtra += MMissileCostPen;
}
if (w.getSize() == WeaponSize.LARGE) {
opRequiredToInstallExtra += LMissileCostPen;
}
} else {
if (w.getSize() == WeaponSize.MEDIUM) {
opRequiredToInstallExtra += MWeapCostPen;
}
if (w.getSize() == WeaponSize.LARGE) {
opRequiredToInstallExtra += LWeapCostPen;
}
}
}
}
usedOP = ship.getVariant().computeOPCost(stats);
totalOP = (int)(ship.getHullSpec().getOrdnancePoints(stats)*(1+OP_Pct/100))+OP_Bonus;
unusedOP = totalOP-usedOP;
opRequiredToInstall = spec.getCostFor(ship.getHullSize()) + opRequiredToInstallExtra;
   return (unusedOP>=opRequiredToInstall);
}

public boolean isApplicableToShip(ShipAPI ship) {
return (true
&& !(ship.getVariant().hasHullMod("missile_reload")) // && !(ship.getVariant().getSMods().contains("missile_reload")) && !(ship.getVariant().getHullSpec().isBuiltInMod("missile_reload"))
&& !(ship.getVariant().hasHullMod("missile_reloadMy")) // && !(ship.getVariant().getSMods().contains("missile_reloadMy")) && !(ship.getVariant().getHullSpec().isBuiltInMod("missile_reloadMy"))
&& !(ship.getVariant().hasHullMod("MHMods_prefabricator")) // && !(ship.getVariant().getSMods().contains("MHMods_prefabricator")) && !(ship.getVariant().getHullSpec().isBuiltInMod("MHMods_prefabricator"))
&& !(ship.getVariant().hasHullMod("mhmods_reloader")) // && !(ship.getVariant().getSMods().contains("mhmods_reloader")) && !(ship.getVariant().getHullSpec().isBuiltInMod("mhmods_reloader"))
&& !(ship.getVariant().hasHullMod("tahlan_scalarautoforge")) // && !(ship.getVariant().getSMods().contains("tahlan_scalarautoforge")) && !(ship.getVariant().getHullSpec().isBuiltInMod("tahlan_scalarautoforge"))
&& !(ship.getVariant().hasHullMod("seven_overcapacity_missile_racks")) // && !(ship.getVariant().getSMods().contains("seven_overcapacity_missile_racks")) && !(ship.getVariant().getHullSpec().isBuiltInMod("seven_overcapacity_missile_racks"))
&& !(ship.getVariant().hasHullMod("hhe_MissileReload")) // && !(ship.getVariant().getSMods().contains("hhe_MissileReload")) && !(ship.getVariant().getHullSpec().isBuiltInMod("hhe_MissileReload"))
&& !(ship.getVariant().hasHullMod("apex_ins_missiles"))
&& !(ship.getVariant().hasHullMod("miniature_PeriodicMissileReload"))
&& !(ship.getVariant().hasHullMod("missile_autoloader"))
&& !(ship.getVariant().hasHullMod("vayra_bear_autoforge"))
&& !(ship.getVariant().hasHullMod("VEmissleracks"))
&& !(ship.getVariant().hasHullMod("VEmagazines"))
&& !(ship.getVariant().hasHullMod("fed_missileforge"))
&& !(ship.getVariant().hasHullMod("aEP_MissilePlatform"))
&& (enoughOPToInstall(ship))
);
}
public String getUnapplicableReason(ShipAPI ship) {
if (ship.getVariant().hasHullMod("vayra_bear_autoforge"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"Blasting Forge" +
"的舰船上。";
}
if (ship.getVariant().hasHullMod("VEmissleracks"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"VEmissleracks" +
"的舰船上。";
}
if (ship.getVariant().hasHullMod("VEmagazines"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"VEmagazines" +
"的舰船上。";
}
if (ship.getVariant().hasHullMod("missile_autoloader"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"Missile Autoloader" +
"的舰船上。";
}
if (ship.getVariant().hasHullMod("missile_reload"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "Auto Reload"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("missile_reloadMy"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "弹药工厂"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("MHMods_prefabricator"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "导弹预制舱(MHM)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("mhmods_reloader"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "自动装填机(MHM)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("tahlan_scalarautoforge"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "Auto Forge(Scalar Tech)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("hhe_MissileReload"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "Missile Reload(HHE)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("seven_overcapacity_missile_racks"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "Over Capacity Missile Racks(seven)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("apex_ins_missiles"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "Integrated Autoforge(Apex)"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("miniature_PeriodicMissileReload"))
{
return "Can not be installed with other auto reload hull mods\n"
+ "无法安装在已安装"
+ "舰载微型导弹工厂(新世界防御联合联盟)模块"
+ "的舰船上。";
}
if (ship.getVariant().hasHullMod("fed_missileforge"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"微型导弹锻炉(The Star Federation)模块" +
"的舰船上。";
}
if (ship.getVariant().hasHullMod("aEP_MissilePlatform"))
{
return //"Can not be installed with other auto reload hull mods\n" +
"无法安装在已安装" +
"发射平台设计(FSF)模块" +
"的舰船上。";
}
   if (!enoughOPToInstall(ship)) {
int OPMore=opRequiredToInstall-unusedOP;
         return "无足够OP用以改装导弹鱼雷火箭，需额外 " + OPMore + " OP以安装此插件。"; //"Insufficient ordnance points due to increased Missile cost, " + -OPMore + " more ordance points needed."
   }
return null;
}
}

ECHO 发表于 2025-4-25 10:56:15

我就是096的aoto啊，我的没问题啊，你看看是不是和别的mod冲突了

齐格隆冬强 发表于 2025-6-12 20:56:25

ECHO 发表于 2025-4-25 10:56
我就是096的aoto啊，我的没问题啊，你看看是不是和别的mod冲突了

你是在0.97下用的吗？

页: [1]

远行星号中文论坛's Archiver

0.96可用的mod迁移到0.97时出错