// ==============================================================================================================
// ==============================================================================================================
public void SetShipAndModules(int ShipTypeID,IReadOnlyCollection <int> ModuleTypeIDs,bool bPassive,bool bADC)
{
Debug.Assert(ShipTypeID < 0 || ShipTypeIDToIndex.ContainsKey(ShipTypeID));
foreach (int ModuleTypeID in ModuleTypeIDs)
{
Debug.Assert(ModuleTypeIDToIndex.ContainsKey(ModuleTypeID));
}
CleanFit(ShipTypeID);
DoAddMoreModules(ModuleTypeIDs);
CheckFitValid();
EventFitChanged();
m_bPassiveTank = bPassive;
m_bAssaultDCEnabled = bADC;
RecalculateTank();
}
// ==============================================================================================================
private void DoAddMoreModules(IReadOnlyCollection <int> ModuleTypeIDs)
{
Dictionary <int,uint> NewModules = new Dictionary <int,uint>();
foreach (int ModuleTypeID in ModuleTypeIDs)
{
if (NewModules.ContainsKey(ModuleTypeID))
{
NewModules[ModuleTypeID]++;
}
else
{
NewModules[ModuleTypeID] = 1;
}
}
foreach (KeyValuePair <int,uint> kvp in NewModules)
{
int ModuleTypeID = kvp.Key;
uint ModuleCount = kvp.Value;
int Index = -1;
bool Ok = ModuleTypeIDToIndex.TryGetValue(ModuleTypeID,out Index);
Debug.Assert(Ok && Index >= 0);
ModuleDescription MD = ModuleDescriptions[Index];
if (m_Fit[MD.m_Slot].ContainsKey(ModuleTypeID))
{
m_Fit[MD.m_Slot][ModuleTypeID] = Math.Max(m_Fit[MD.m_Slot][ModuleTypeID],ModuleCount);
}
else
{
m_Fit[MD.m_Slot][ModuleTypeID] = ModuleCount;
}
}
if (m_ShipTypeID > 0)
{
int Index = -1;
if (ShipTypeIDToIndex.TryGetValue(ShipTypeID,out Index))
{
ShipDescription SD = ShipDescriptions[Index];
// recalc slot layout for t3 cruisers
RecalcStategicCruiserSlotLayout(SD);
}
}
}
// ==============================================================================================================
private void RecalculateTank()
{
if (!m_ValidFit || m_ShipTypeID < 0)
{
TankForInvalidFit();
}
else
{
int ShipIndex = -1;
bool Ok = ShipTypeIDToIndex.TryGetValue(m_ShipTypeID, out ShipIndex);
Debug.Assert(Ok && ShipIndex >= 0 && ShipIndex < ShipDescriptions.Count);
ShipDescription SD = ShipDescriptions[ShipIndex];
Dictionary <int, uint> AllModuleIDs = new Dictionary <int, uint>();
foreach (SLOT Slot in Enum.GetValues(typeof(SLOT)))
{
foreach (KeyValuePair <int,uint> ModuleAndCount in m_Fit[Slot])
{
AllModuleIDs[ModuleAndCount.Key] = ModuleAndCount.Value;
}
}
bool isPolarized = false;
List <Tuple <ModuleDescription,uint> > AllModules = new List <Tuple <ModuleDescription,uint> >();
foreach (KeyValuePair <int,uint> kvp in AllModuleIDs)
{
int Index = -1;
Ok = ModuleTypeIDToIndex.TryGetValue(kvp.Key,out Index);
Debug.Assert(Ok);
isPolarized |= IsPolarized(ModuleDescriptions[Index]);
AllModules.Add(new Tuple <ModuleDescription,uint>(ModuleDescriptions[Index],kvp.Value));
}
m_Tank[LAYER.SHIELD] = GetLayerTank(SD.m_ShieldHP,SD.m_ShieldHPMultiplier,SD.m_ShieldResistEM,SD.m_ShieldResistThermal,SD.m_ShieldResistKinetic,SD.m_ShieldResistExplosive,isPolarized,LAYER.SHIELD,AllModules,SD.m_OverheatingBonus);
m_Tank[LAYER.ARMOR] = GetLayerTank(SD.m_ArmorHP,SD.m_ArmorHPMultiplier,SD.m_ArmorResistEM,SD.m_ArmorResistThermal,SD.m_ArmorResistKinetic,SD.m_ArmorResistExplosive,isPolarized,LAYER.ARMOR,AllModules,SD.m_OverheatingBonus);
m_Tank[LAYER.HULL] = GetLayerTank(SD.m_HullHP,SD.m_HullHPMultiplier,SD.m_HullResistEM,SD.m_HullResistThermal,SD.m_HullResistKinetic,SD.m_HullResistExplosive,isPolarized,LAYER.HULL,AllModules,SD.m_OverheatingBonus);
}
EventTankChanged();
}
private void CheckFitValid()
{
m_ValidFit = true;
foreach (SLOT Slot in Enum.GetValues(typeof(SLOT)))
{
Debug.Assert(m_Fit.ContainsKey(Slot));
uint ModuleCount = 0;
foreach (KeyValuePair <int,uint> M in m_Fit[Slot])
{
ModuleCount += M.Value;
}
if (ModuleCount > m_Slots[Slot])
{
m_ValidFit = false;
break;
}
}
if (m_ValidFit)
{
if (m_ShipTypeID > 0)
{
int Index = -1;
if (ShipTypeIDToIndex.TryGetValue(ShipTypeID,out Index))
{
ShipDescription SD = ShipDescriptions[Index];
if (SD.m_SubsystemSlots > 0)
{
foreach (SLOT Slot in new SLOT[] { SLOT.SUB_CORE,SLOT.SUB_DEFENSIVE,SLOT.SUB_OFFENSIVE,SLOT.SUB_PROPULSION })
{
if (m_Fit[Slot].Count > 1)
{
m_ValidFit = false;
break;
}
#region Check that all 4 subsystems are filled. Not required anymore, coz we can have partial t3c fits.
//if (m_Fit[Slot].Count != 1) {
// m_ValidFit = false;
// break;
//}
#endregion
// Check that subsystems belong to current t3 hull.
foreach (KeyValuePair <int,uint> kvp in m_Fit[Slot])
{
Index = -1;
if (!ModuleTypeIDToIndex.TryGetValue(kvp.Key,out Index) || Index < 0)
{
m_ValidFit = false;
break;
}
ModuleDescription md = ModuleDescriptions[Index];
if (md.m_ShipTypeID < 0 || md.m_ShipTypeID != m_ShipTypeID)
{
m_ValidFit = false;
break;
}
if (kvp.Value != 1)
{
m_ValidFit = false;
break;
}
break;
}
}
}
}
}
}
CheckFullFit();
}
private void RecalcStategicCruiserSlotLayout(ShipDescription SD)
{
if (SD.m_SubsystemSlots > 0)
{
int nSubsystems = ((m_Fit[SLOT.SUB_CORE].Count > 0) ? 1 : 0) + ((m_Fit[SLOT.SUB_DEFENSIVE].Count > 0) ? 1 : 0) + ((m_Fit[SLOT.SUB_OFFENSIVE].Count > 0) ? 1 : 0) + ((m_Fit[SLOT.SUB_PROPULSION].Count > 0) ? 1 : 0);
if (nSubsystems == 4)
{
uint HS = SD.m_HighSlots;
uint MS = SD.m_MedSlots;
uint LS = SD.m_LowSlots;
foreach (SLOT Slot in new SLOT[] { SLOT.SUB_CORE,SLOT.SUB_DEFENSIVE,SLOT.SUB_OFFENSIVE,SLOT.SUB_PROPULSION })
{
foreach (KeyValuePair <int,uint> kvp in m_Fit[Slot])
{
int ModuleTypeID = kvp.Key;
int Index = -1;
bool Ok = ModuleTypeIDToIndex.TryGetValue(ModuleTypeID,out Index);
Debug.Assert(Ok && Index > 0);
ModuleDescription MD = ModuleDescriptions[Index];
if (MD.m_ShipTypeID == m_ShipTypeID)
{
if (MD.m_Effects.ContainsKey(LAYER.NONE))
{
foreach (KeyValuePair <EFFECT,Dictionary <ACTIVE,Tuple <float,int> > > effect in MD.m_Effects[LAYER.NONE])
{
if (effect.Value.ContainsKey(ACTIVE.PASSIVE))
{
switch (effect.Key)
{
case EFFECT.HIGH_SLOTS:
HS += (uint)effect.Value[ACTIVE.PASSIVE].Item1;
break;
case EFFECT.MEDIUM_SLOTS:
MS += (uint)effect.Value[ACTIVE.PASSIVE].Item1;
break;
case EFFECT.LOW_SLOTS:
LS += (uint)effect.Value[ACTIVE.PASSIVE].Item1;
break;
}
}
}
}
}
break; // only process first module. If there is more than one, fit is invalid anyway.
}
}
m_Slots[SLOT.HIGH] = HS;
m_Slots[SLOT.MEDIUM] = MS;
m_Slots[SLOT.LOW] = LS;
}
else
{
m_Slots[SLOT.HIGH] = 8;
m_Slots[SLOT.MEDIUM] = 8;
m_Slots[SLOT.LOW] = 8;
}
}
}