package data.hullmods;

import com.fs.starfarer.api.combat.BaseHullMod;
import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.combat.ShieldAPI;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.combat.ShieldAPI.ShieldType;
import com.fs.starfarer.api.combat.ShipAPI.HullSize;
import com.fs.starfarer.api.combat.WeaponAPI;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.combat.CombatEngineAPI;
import com.fs.starfarer.api.combat.WeaponAPI.WeaponType;
import com.fs.starfarer.api.util.IntervalUtil;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.combat.DamageType;

import org.lwjgl.util.vector.Vector2f;
import java.awt.Color;
import java.util.Set;
import java.util.HashSet;

//modifyMult增加多少倍
//modifyFlat增加多少数值 

//以下为船体增强
public class Super_Plug extends BaseHullMod 
{
	// ===================== 新增：装甲按时间片恢复（写法B，可控系数） =====================
	// 每秒基础恢复比例（相对每格最大装甲值）
	private static final float ARMOR_REGEN_BASE_PER_SEC = 0.035f;   // 例如 0.02 = 每秒按每格最大装甲的 2% 恢复
	// 恢复效率系数（你要的“像 1f 那样”的控制量；1f=保持当前，0.5f=半速，2f=双倍）
	private static final float ARMOR_REGEN_EFFICIENCY   = 1f;
	// 恢复节拍（固定时间片）
	private static final float ARMOR_TICK_SECONDS       = 0.5f;    // 每 0.5 秒跳一次

	// ===================== 新增：方案A（技能系统冷却/回充/次数） =====================
	// 注意：方案A是在创建舰船时生效，作用于“安装了该HullMod的船”，与阵营无关
	// 冷却时间倍率（越小越快；0f=真·无冷却；推荐先用0.25f测试）
	private static final float SYSTEM_COOLDOWN_MULT = 0f; // 可改为 0f -> 0CD
	// 回充速度倍率（仅对“有充能”的系统生效）
	private static final float SYSTEM_REGEN_MULT    = 10f;    // 2f=两倍回充
	// 额外可用次数（仅对“有充能”的系统生效；也可用 modifyMult 视SDK版本）
	private static final float SYSTEM_USES_FLAT     = 0f;    // 额外 +1 次

	// ===================== 新增：船体结构（HP）按时间片恢复（与装甲同节拍，可控系数） =====================
	// 每秒基础恢复比例（相对最大结构值）
	private static final float HULL_REGEN_BASE_PER_SEC  = 0.035f;   // 例如 0.02 = 每秒按最大结构的 2% 恢复
	// 恢复效率系数（1f=正常、0.5f=半速、2f=双倍）
	private static final float HULL_REGEN_EFFICIENCY    = 1f;

	// ===================== 过载触发：EMP圆环扩散（视觉+纯辐能，不伤友军） =====================
	private static final boolean RING_ON_OVERLOAD_ENABLED = true; // 总开关

	// 视觉 & 动画参数（保留：持续1s，最大半径1600；但重做视觉内容以更好看且省性能）
	private static final float RING_DURATION      = 3f;
	private static final float RING_MAX_RADIUS    = 1600f;
	private static final float RING_THICKNESS_VIS = 30f;    // 电弧稍厚，视觉更“富”
	// 视觉改造：低密度电弧 + 冲击波平滑粒子 + 余烬火花
	private static final int   RING_ARCS_PER_STEP = 20;     // 步进里电弧数（取代原先每帧18）
	private static final int   RING_DOTS_PER_STEP = 72;    // 冲击波上布点（平滑粒子）
	private static final int   SPARKS_PER_STEP    = 40;    // 外抛余烬粒子

	private static final Color RING_FRINGE_COLOR  = new Color(140, 220, 255, 210); // 外沿色
	private static final Color RING_CORE_COLOR    = new Color(255, 255, 255, 240); // 核心色
	private static final Color SHOCKWAVE_COLOR    = new Color(90, 200, 255, 120);  // 冲击波淡蓝
	private static final Color SPARK_COLOR        = new Color(255, 230, 160, 220); // 金色余烬

	// 纯辐能堆积参数（不造成装甲/结构伤害）
	private static final float   RING_FLUX_MIN    = 0.5f;
	private static final float   RING_FLUX_MAX    = 2.0f;
	private static final boolean RING_FLUX_HARD   = true;
	private static final float   RING_BAND_WIDTH  = 120f;

	// ===================== 性能开关（仅限本环形特效） =====================
	// 距离裁剪：玩家看不到远处爆炸时，不渲染，不结算（或降低频率）
	private static final float RING_MAX_RENDER_DISTANCE = 2000f; // 超过则仅低频结算或跳过
	// 渲染/结算步进：不是每帧，而是每 0.05 s 处理一帧视觉与结算
	private static final float RING_VIS_STEP_SECONDS    = 0.05f;

	// 自定义数据 key
	private static final String ARMOR_REGEN_KEY   = "superplug_armor_regen_key";
	private static final String OVERLOAD_FLAG_KEY = "superplug_overload_flag";
	private static final String RING_DATA_KEY     = "superplug_ring_data";

	private static class ArmorRegenData {
		IntervalUtil interval = new IntervalUtil(ARMOR_TICK_SECONDS, ARMOR_TICK_SECONDS);
	}
	private static class RingWave { 
		float t = 0f; 
		float visTimer = 0f; // 性能：视觉/结算步进累加器
		boolean spawnedShock = false; // 只在开始时放一次爆心光爆
	} // EMP 圆环状态

	
	@Override
	public void applyEffectsBeforeShipCreation(HullSize hullSize, MutableShipStatsAPI stats, String id) 
		{
			stats.getCombatEngineRepairTimeMult().modifyMult(id, 1f);			//战斗修理引擎时间
			stats.getCombatWeaponRepairTimeMult().modifyMult(id, 1f);			//战斗修理武器时间
	
			stats.getBaseCRRecoveryRatePercentPerDay().modifyMult(id, 1f);	//基础日CR恢复速度			
			stats.getMaxCombatReadiness().modifyMult(id, 2f);				//CR最大值			
			stats.getRepairRatePercentPerDay().modifyMult(id, 1f);			//基础日修理率
				
			stats.getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
			stats.getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
			stats.getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
			stats.getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
						
			stats.getEnergyWeaponFluxCostMod().modifyMult(id, 0.1f);		//能量武器幅能消耗
			stats.getBallisticWeaponFluxCostMod().modifyMult(id, 0.1f);		//实弹武器幅能消耗
			stats.getMissileWeaponFluxCostMod().modifyMult(id, 0.1f);		//导弹类武器幅能消耗
			stats.getBeamWeaponFluxCostMult().modifyMult(id, 0.1f);			//光束武器幅能消耗
			
			stats.getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
			stats.getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
			stats.getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
			
			stats.getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度
	
			stats.getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
			stats.getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
			stats.getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
			stats.getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程
	
			stats.getBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);			//光束类PD射程
			stats.getNonBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);		//非光束类PD射程
			
			stats.getWeaponTurnRateBonus().modifyMult(id, 1f);				//武器旋转速率		
			stats.getBeamWeaponTurnRateBonus().modifyMult(id, 1f);			//光束武器旋转速率
			stats.getSightRadiusMod().modifyMult(id, 10f);					//视野半径
	
			stats.getWeaponHealthBonus().modifyMult(id, 1f);				//武器血量
			stats.getEngineHealthBonus().modifyMult(id, 1f);				//引擎血量
			stats.getEngineDamageTakenMult().modifyMult(id, 1f);			//引擎受到伤害
	
			stats.getBallisticAmmoBonus().modifyMult(id, 10f);				//实弹弹药
			stats.getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
			stats.getMissileAmmoBonus().modifyMult(id, 2f);				//导弹弹药
			
			stats.getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
			stats.getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
			stats.getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
			stats.getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
			stats.getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
			stats.getMissileGuidance().modifyMult(id, 1f);					//导弹制导
			
			stats.getAutofireAimAccuracy().modifyMult(id, 1f);					//自动开火准确率
			stats.getMaxRecoilMult().modifyMult(id, 1f);						//最大后座力
			stats.getRecoilPerShotMult().modifyMult(id, 1f);					//每击后座力
	
			stats.getMaxSpeed().modifyMult(id, 1f);							//最大速度
			stats.getFuelMod().modifyMult(id, 10f);							//携带燃油量
			stats.getCargoMod().modifyMult(id, 10f);							//货仓量（倍率）
			stats.getMaxCrewMod().modifyMult(id, 1f);	                    //载员数量
			stats.getMinCrewMod().modifyMult(id, 0.1f); 					//最小船员数量
			stats.getMaxBurnLevel().modifyMult(id, 1.5f);						//最大航行速度
			stats.getFuelUseMod().modifyMult(id, 0.1f);						//燃油消耗量
			stats.getSuppliesPerMonth().modifyMult(id, 1f);   			    //基础补给消耗
			stats.getCRPerDeploymentPercent().modifyMult(id, 1f);			//每次参战CR消耗
			
	
			stats.getFluxCapacity().modifyMult(id, 1f);						//Flux总量
			stats.getFluxDissipation().modifyMult(id, 1f);					//Flux消退速率
			stats.getVentRateMult().modifyMult(id, 1f);					    //强制Flux消散速度
	
			stats.getAcceleration().modifyMult(id, 1f);						//加速度
			stats.getDeceleration().modifyMult(id, 1f);						//减速
			stats.getTurnAcceleration().modifyMult(id, 1f);					//转向加速度
			stats.getMaxTurnRate().modifyMult(id, 1f);						//最大转向速率
			stats.getZeroFluxSpeedBoost().modifyMult(id, 1.5f);				//0幅能时船速
	
			stats.getShieldArcBonus().modifyMult(id, 1f);					//盾弧度
			stats.getShieldUpkeepMult().modifyMult(id, 1f);					//保持护盾能量消耗
			stats.getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
			stats.getShieldTurnRateMult().modifyMult(id, 1f);				//护盾转向速度
			stats.getShieldUnfoldRateMult().modifyMult(id, 1f);			//护盾打开速度
			
			
			stats.getPeakCRDuration().modifyMult(id, 10f);					//CR峰值持续时间
			stats.getCRLossPerSecondPercent().modifyMult(id, 1f);		    //CR消退速度
			stats.getOverloadTimeMod().modifyMult(id, 1f);				//舰船过载时间
	
			stats.getHullBonus().modifyMult(id, 1f);                        //耐久,结构
			stats.getArmorBonus().modifyMult(id, 1f);                        //装甲
			stats.getSensorStrength().modifyMult(id, 10f);                   //雷达范围
			stats.getSuppliesToRecover().modifyMult(id, 1f);                 // 修复补给消耗
			
			stats.getFighterRefitTimeMult().modifyMult(id, 0.1f);      		//战机整备速率回复时间
			stats.getNumFighterBays().modifyMult(id, 3f);					//加倍战机数量槽
			stats.getCrewLossMult().modifyMult(id, 0.1f);					//舰船人员战损倍数	
			stats.getFighterWingRange().modifyMult(id, 2f);					//战机交战范围

			// ===================== 新增：方案A（系统冷却/回充/次数） =====================
			stats.getSystemCooldownBonus().modifyMult(id, SYSTEM_COOLDOWN_MULT); // 技能冷却倍率（0f=0CD）
			stats.getSystemRegenBonus().modifyMult(id, SYSTEM_REGEN_MULT);       //技能回充倍率（仅有充能的系统）
			stats.getSystemUsesBonus().modifyFlat(id, SYSTEM_USES_FLAT);         //额外可用次数（仅有充能的系统）
		}
		
	//以下为船体所属战机增强
	public void applyEffectsToFighterSpawnedByShip( ShipAPI fighter, ShipAPI ship, String id )
		{
			
			fighter.getMutableStats().getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
			fighter.getMutableStats().getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
			fighter.getMutableStats().getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
			fighter.getMutableStats().getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
		
			fighter.getMutableStats().getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度
			fighter.getMutableStats().getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
			fighter.getMutableStats().getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
			fighter.getMutableStats().getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
			fighter.getMutableStats().getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程
			
			fighter.getMutableStats().getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
			fighter.getMutableStats().getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
			fighter.getMutableStats().getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
			
			fighter.getMutableStats().getBallisticAmmoBonus().modifyMult(id, 10f);			//实弹弹药
			fighter.getMutableStats().getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
			fighter.getMutableStats().getMissileAmmoBonus().modifyMult(id, 10f);			//导弹弹药
			
			fighter.getMutableStats().getEnergyWeaponFluxCostMod().modifyMult(id, 0f);			//能量武器幅能消耗
			fighter.getMutableStats().getBallisticWeaponFluxCostMod().modifyMult(id, 0f);		//实弹武器幅能消耗
			fighter.getMutableStats().getMissileWeaponFluxCostMod().modifyMult(id, 0f);			//导弹类武器幅能消耗
			fighter.getMutableStats().getBeamWeaponFluxCostMult().modifyMult(id, 0f);			//光束武器幅能消耗
			
			fighter.getMutableStats().getMaxSpeed().modifyMult(id, 3f);							//最大速度
			fighter.getMutableStats().getAcceleration().modifyMult(id, 3f);						//加速度
			fighter.getMutableStats().getDeceleration().modifyMult(id, 3f);						//减速
			fighter.getMutableStats().getTurnAcceleration().modifyMult(id, 3f);					//转向加速度
			fighter.getMutableStats().getMaxTurnRate().modifyMult(id, 3f);						//最大转向速率
			
			fighter.getMutableStats().getArmorBonus().modifyMult(id, 1f);                        //装甲
			fighter.getMutableStats().getHullBonus().modifyMult(id, 1f);                        //耐久,结构
			fighter.getMutableStats().getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
			
			fighter.getMutableStats().getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
			fighter.getMutableStats().getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
			fighter.getMutableStats().getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
			fighter.getMutableStats().getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
			fighter.getMutableStats().getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
			fighter.getMutableStats().getMissileGuidance().modifyMult(id, 1f);					//导弹制导
			
	
		}
		
	//弹药工厂
	public static String MR_DATA_KEY = "core_reload_data_key";
	
	public static class PeriodicMissileReloadData 
	{
		IntervalUtil interval = new IntervalUtil(10f, 10f);
	}

	public void advanceInCombat(ShipAPI ship, float amount) 
	{
		super.advanceInCombat(ship, amount);

		if (!ship.isAlive()) return;
		
		CombatEngineAPI engine = Global.getCombatEngine();
		if (engine == null || engine.isPaused()) return;

		// ===================== 新增：装甲/结构定时恢复（写法B） =====================
		String ak = ARMOR_REGEN_KEY + "_" + ship.getId();
		ArmorRegenData aregen = (ArmorRegenData) engine.getCustomData().get(ak);
		if (aregen == null) {
			aregen = new ArmorRegenData();
			engine.getCustomData().put(ak, aregen);
		}
		aregen.interval.advance(amount);
		if (aregen.interval.intervalElapsed() && ship.getArmorGrid() != null) {
			float[][] grid = ship.getArmorGrid().getGrid();
			if (grid != null) {
				final float cellMax = ship.getArmorGrid().getMaxArmorInCell();
				final float tick = aregen.interval.getElapsed(); // 本次间隔真实秒数

				// —— 装甲：每格按“最大值 × 比例 × 效率 × tick”恢复 ——
				final float armorDelta = cellMax * ARMOR_REGEN_BASE_PER_SEC * ARMOR_REGEN_EFFICIENCY * tick;
				for (int x = 0; x < grid.length; x++) {
					for (int y = 0; y < grid[0].length; y++) {
						float v = grid[x][y] + armorDelta;
						if (v > cellMax) v = cellMax;
						grid[x][y] = v;
					}
				}
				// —— 结构：按“最大结构 × 比例 × 效率 × tick”恢复 ——
				float hp = ship.getHitpoints();
				float hpMax = ship.getMaxHitpoints();
				if (hp < hpMax) {
					final float hullDelta = hpMax * HULL_REGEN_BASE_PER_SEC * HULL_REGEN_EFFICIENCY * tick;
					ship.setHitpoints(Math.min(hpMax, hp + hullDelta));
				}

				ship.syncWithArmorGridState(); // 同步显示
			}
		}

		// ===================== 过载触发：EMP圆环扩散（视觉+纯辐能，不伤友军） =====================
		if (RING_ON_OVERLOAD_ENABLED && ship.getFluxTracker() != null) {
			String ok = OVERLOAD_FLAG_KEY + "_" + ship.getId();
			boolean wasOver = Boolean.TRUE.equals(engine.getCustomData().get(ok));
			boolean isOver  = ship.getFluxTracker().isOverloaded();

			if (isOver && !wasOver) {
				// 进入过载瞬间：启动一条环波
				String rk = RING_DATA_KEY + "_" + ship.getId();
				engine.getCustomData().put(rk, new RingWave());
			}
			if (isOver != wasOver) {
				engine.getCustomData().put(ok, isOver);
			}

			// 推进&渲染&结算：如果环波存在则推进
			String rk = RING_DATA_KEY + "_" + ship.getId();
			Object obj = engine.getCustomData().get(rk);
			if (obj instanceof RingWave) {
				RingWave ring = (RingWave) obj;
				ring.t += amount;
				ring.visTimer += amount;

				if (ring.t >= RING_DURATION) {
					engine.getCustomData().remove(rk); // 结束
				} else {
					// 仅按步进处理（减少每帧调用的昂贵开销）
					if (ring.visTimer < RING_VIS_STEP_SECONDS) {
						return;
					}
					// 消耗步进
					ring.visTimer = 0f;

					float progress = ring.t / RING_DURATION;
					float curR = RING_MAX_RADIUS * progress;

					// —— 距离裁剪：玩家远离则跳过视觉（可选也跳过结算以进一步降负载）
					ShipAPI player = engine.getPlayerShip();
					boolean farAway = false;
					if (player != null) {
						float d = Misc.getDistance(ship.getLocation(), player.getLocation());
						farAway = d > RING_MAX_RENDER_DISTANCE;
					}

					// —— 视觉：更好看的“冲击波 + 少量粗电弧 + 余烬火花”
					if (!farAway) {
						Vector2f center = ship.getLocation();

						// 1) 开始瞬间：一次性爆心光爆（省成本但观感强）
						if (!ring.spawnedShock) {
							ring.spawnedShock = true;
							// 光爆
							engine.spawnExplosion(center, new Vector2f(0,0), new Color(255,255,255,255), 
								Math.max(120f, ship.getCollisionRadius() * 0.6f), 0.25f);
							// 爆心亮斑
							engine.addSmoothParticle(center, new Vector2f(0,0), 
								Math.max(200f, ship.getCollisionRadius()), 1.2f, 0.15f, new Color(255,240,220,255));
						}

						// 2) 冲击波圆环：由平滑粒子在圆周上均匀布点形成“光圈”
						int dots = RING_DOTS_PER_STEP;
						float ringSize = 30f + curR * 0.06f;      // 点的尺寸随半径略增
						float bright   = 0.8f * (1f - progress);   // 随时间衰减
						for (int i = 0; i < dots; i++) {
							float ang = (360f / dots) * i + (float)Math.random()*4f;
							float rad = (float) Math.toRadians(ang);
							Vector2f to = new Vector2f(
									center.x + (float) Math.cos(rad) * curR,
									center.y + (float) Math.sin(rad) * curR
							);
							engine.addSmoothParticle(to, new Vector2f(0,0), ringSize, bright, 0.4f, SHOCKWAVE_COLOR);
						}

						// 3) 稀疏但更粗的电弧：只做少量，避免昂贵
						int arcs = Math.max(3, Math.min(10, (int)(ship.getCollisionRadius() / 300f) + RING_ARCS_PER_STEP));
						float baseAngle = (engine.getTotalElapsedTime(false) * 120f) % 360f;
						for (int i = 0; i < arcs; i++) {
							float ang = baseAngle + (360f / arcs) * i + (float)Math.random() * 8f;
							float rad = (float) Math.toRadians(ang);
							Vector2f to = new Vector2f(
									center.x + (float) Math.cos(rad) * curR,
									center.y + (float) Math.sin(rad) * curR
							);
							engine.spawnEmpArcVisual(center, ship, to, null, RING_THICKNESS_VIS, RING_FRINGE_COLOR, RING_CORE_COLOR);
						}

						// 4) 外抛余烬：从圆环向外飞出的小粒子，短暂消散
						for (int i = 0; i < SPARKS_PER_STEP; i++) {
							float ang = (float)(Math.random() * 360f);
							float rad = (float) Math.toRadians(ang);
							Vector2f loc = new Vector2f(
								center.x + (float)Math.cos(rad) * curR,
								center.y + (float)Math.sin(rad) * curR
							);
							Vector2f vel = new Vector2f(
								(float)Math.cos(rad) * (80f + (float)Math.random()*120f),
								(float)Math.sin(rad) * (80f + (float)Math.random()*120f)
							);
							float size = 6f + (float)Math.random()*10f;
							float life = 0.35f + (float)Math.random()*0.4f;
							engine.addHitParticle(loc, vel, size, 0.8f, life, SPARK_COLOR);
						}
					}

					// —— 纯辐能结算：也采用步进频率；如果距离很远，可跳过以进一步降负载
					if (!farAway) {
						float bandHalf = RING_BAND_WIDTH * 0.5f;
						for (ShipAPI other : engine.getShips()) {
							if (other == null || !other.isAlive()) continue;
							if (other.getOwner() == ship.getOwner()) continue; // 不伤友军

							float dist = Misc.getDistance(ship.getLocation(), other.getLocation());
							if (Math.abs(dist - curR) > bandHalf) continue; // 不在环带上

							float edge = Math.abs(dist - curR) / bandHalf; // 0~1
							float t = Math.max(0f, 1f - edge);            // 环带中心 t=1，外缘→0

							// === 按“船舶最大辐能上限 × 线性插值(最小/最大倍率)”结算 ===
							float emitterMaxFlux = ship.getFluxTracker().getMaxFlux(); // 船舶总辐能上限（最大辐能）
							float multiplier = RING_FLUX_MIN + (RING_FLUX_MAX - RING_FLUX_MIN) * t;
							float flux = emitterMaxFlux * multiplier;

							if (other.getFluxTracker() != null && flux > 0f) {
								other.getFluxTracker().increaseFlux(flux, RING_FLUX_HARD);
							}
						}
					}
				}
			}
		}

		
		// ===================== 弹药工厂（每10秒：0弹瞬满） =====================
		String key = MR_DATA_KEY + "_" + ship.getId();
		PeriodicMissileReloadData data = (PeriodicMissileReloadData) engine.getCustomData().get(key);
		if (data == null) 
		{
			data = new PeriodicMissileReloadData();
			engine.getCustomData().put(key, data);
		}
		data.interval.advance(amount);
		if (data.interval.intervalElapsed()) 
		{
			for (WeaponAPI w : ship.getAllWeapons()) 
			{
				if (w.usesAmmo() && w.getAmmo() < w.getMaxAmmo()) 
				{
					if(w.getAmmo() == 0)
					{
					 w.setAmmo(w.getMaxAmmo());			
					}
				}
			}
		}
	}
	


}