internal static IEnumerable <StationModules.StationModule> EnumerateUniqueStationModules(
GameSession game,
StationInfo station)
{
HashSet <ModuleEnums.StationModuleType> consideredTypes = new HashSet <ModuleEnums.StationModuleType>();
foreach (LogicalModuleMount stationModuleMount in game.GetStationModuleMounts(station))
{
LogicalModuleMount mount = stationModuleMount;
List <StationModules.StationModule> matchingModules = ((IEnumerable <StationModules.StationModule>)StationModules.Modules).Where <StationModules.StationModule>((Func <StationModules.StationModule, bool>)(val => val.SlotType == mount.ModuleType)).ToList <StationModules.StationModule>();
Player stationPlayer = game.GetPlayerObject(station.DesignInfo.PlayerID);
foreach (StationModules.StationModule stationModule in matchingModules)
{
if (!consideredTypes.Contains(stationModule.SMType) && stationModule.SMType != ModuleEnums.StationModuleType.AlienHabitation && stationModule.SMType != ModuleEnums.StationModuleType.LargeAlienHabitation)
{
consideredTypes.Add(stationModule.SMType);
string faction = AssetDatabase.GetModuleFactionName(stationModule.SMType);
if (faction.Length > 0)
{
if (!(faction == "zuul") || !stationModule.SlotType.ToString().ToUpper().Contains("ALIEN"))
{
IEnumerable <PlayerInfo> list = (IEnumerable <PlayerInfo>)game.GameDatabase.GetStandardPlayerInfos().ToList <PlayerInfo>();
if (list.Where <PlayerInfo>((Func <PlayerInfo, bool>)(x => game.GameDatabase.GetFactionName(x.FactionID) == faction)).Count <PlayerInfo>() > 0)
{
bool flag = false;
foreach (PlayerInfo playerInfo in list.Where <PlayerInfo>((Func <PlayerInfo, bool>)(x =>
{
if (game.GameDatabase.GetFactionName(x.FactionID) == faction)
{
return(x.ID != stationPlayer.ID);
}
return(false);
})))
{
flag = game.GameDatabase.GetDiplomacyInfo(stationPlayer.ID, playerInfo.ID).isEncountered;
if (flag)
{
break;
}
}
if (faction != stationPlayer.Faction.Name && !flag || faction != stationPlayer.Faction.Name && flag && stationModule.SMType.ToString().ToUpper().Contains("FOREIGN") || faction == stationPlayer.Faction.Name && !flag && stationModule.SMType.ToString().ToUpper().Contains("FOREIGN"))
{
continue;
}
}
else
{
continue;
}
}
else
{
continue;
}
}
yield return(stationModule);
}
}
}
}
private static DesignSectionInfo GetDesignSectionInfoFromRow(
Row row,
SQLiteConnection db,
AssetDatabase assets)
{
int integer = row[0].SQLiteValueToInteger();
string filename = row[1].SQLiteValueToString();
DesignSectionInfo designSection = new DesignSectionInfo()
{
ID = integer,
FilePath = filename,
ShipSectionAsset = assets.GetShipSectionAsset(filename),
WeaponBanks = DesignsCache.GetWeaponBankInfosForDesignSection(db, integer).ToList <WeaponBankInfo>(),
Techs = DesignsCache.GetTechsForDesignSection(db, integer).ToList <int>()
};
List <DesignModuleInfo> list = DesignsCache.GetModuleInfosForDesignSection(db, designSection).ToList <DesignModuleInfo>();
designSection.Modules = new List <DesignModuleInfo>();
foreach (LogicalModuleMount module in designSection.ShipSectionAsset.Modules)
{
LogicalModuleMount mount = module;
DesignModuleInfo designModuleInfo = list.FirstOrDefault <DesignModuleInfo>((Func <DesignModuleInfo, bool>)(x => x.MountNodeName == mount.NodeName));
if (designModuleInfo != null)
{
designSection.Modules.Add(designModuleInfo);
list.Remove(designModuleInfo);
}
}
return(designSection);
}
internal static void ConfirmStationQueuedItems(
GameSession game,
StationInfo station,
Dictionary <ModuleEnums.StationModuleType, int> queuedItemMap)
{
List <LogicalModuleMount> stationModuleMounts = game.GetAvailableStationModuleMounts(station);
foreach (KeyValuePair <ModuleEnums.StationModuleType, int> keyValuePair in queuedItemMap.ToList <KeyValuePair <ModuleEnums.StationModuleType, int> >())
{
KeyValuePair <ModuleEnums.StationModuleType, int> thing = keyValuePair;
int num = thing.Value;
while (num > 0)
{
List <DesignModuleInfo> list1 = game.GameDatabase.GetQueuedStationModules(station.DesignInfo.DesignSections[0]).ToList <DesignModuleInfo>();
List <DesignModuleInfo> modules = station.DesignInfo.DesignSections[0].Modules;
List <LogicalModuleMount> list2 = stationModuleMounts.Where <LogicalModuleMount>((Func <LogicalModuleMount, bool>)(x => x.ModuleType == AssetDatabase.StationModuleTypeToMountTypeMap[thing.Key].ToString())).ToList <LogicalModuleMount>();
bool flag = false;
foreach (LogicalModuleMount logicalModuleMount in list2)
{
LogicalModuleMount mount = logicalModuleMount;
if (list1.Where <DesignModuleInfo>((Func <DesignModuleInfo, bool>)(x => x.MountNodeName == mount.NodeName)).Count <DesignModuleInfo>() == 0 && modules.Where <DesignModuleInfo>((Func <DesignModuleInfo, bool>)(x => x.MountNodeName == mount.NodeName)).Count <DesignModuleInfo>() == 0)
{
List <PlayerInfo> list3 = game.GameDatabase.GetPlayerInfos().ToList <PlayerInfo>();
Player playerObject = game.GetPlayerObject(station.PlayerID);
string moduleFactionDefault = StationModuleQueue.GetModuleFactionDefault(thing.Key, playerObject.Faction);
int moduleId = game.GameDatabase.GetModuleID(game.AssetDatabase.GetStationModuleAsset(thing.Key, moduleFactionDefault), list3.First <PlayerInfo>((Func <PlayerInfo, bool>)(x => game.GameDatabase.GetFactionName(x.FactionID) == moduleFactionDefault)).ID);
game.GameDatabase.InsertQueuedStationModule(station.DesignInfo.DesignSections[0].ID, moduleId, new int?(), mount.NodeName, thing.Key);
--num;
flag = true;
break;
}
}
if (!flag)
{
break;
}
}
queuedItemMap[thing.Key] = 0;
}
}
public static CreateShipDummyParams ObtainShipDummyParams(
App game,
ShipInfo shipInfo)
{
IEnumerable <string> modules = game.AssetDatabase.Modules.Select <LogicalModule, string>((Func <LogicalModule, string>)(x => x.ModuleName));
IEnumerable <string> weapons = game.AssetDatabase.Weapons.Select <LogicalWeapon, string>((Func <LogicalWeapon, string>)(x => x.Name));
DesignInfo designInfo = shipInfo.DesignInfo;
List <ShipSectionAsset> shipSectionAssetList = new List <ShipSectionAsset>();
List <ModuleAssignment> moduleAssignmentList = new List <ModuleAssignment>();
List <WeaponAssignment> weaponAssignmentList = new List <WeaponAssignment>();
foreach (DesignSectionInfo designSection in designInfo.DesignSections)
{
DesignSectionInfo sectionInfo = designSection;
ShipSectionAsset shipSectionAsset = game.AssetDatabase.ShipSections.First <ShipSectionAsset>((Func <ShipSectionAsset, bool>)(x => x.FileName == sectionInfo.FilePath));
shipSectionAssetList.Add(shipSectionAsset);
foreach (LogicalBank bank1 in shipSectionAsset.Banks)
{
LogicalBank bank = bank1;
WeaponBankInfo weaponBankInfo = sectionInfo.WeaponBanks.FirstOrDefault <WeaponBankInfo>((Func <WeaponBankInfo, bool>)(x => x.BankGUID == bank.GUID));
bool flag = false;
if (weaponBankInfo != null && weaponBankInfo.WeaponID.HasValue)
{
string weaponName = Path.GetFileNameWithoutExtension(game.GameDatabase.GetWeaponAsset(weaponBankInfo.WeaponID.Value));
WeaponAssignment weaponAssignment = new WeaponAssignment()
{
ModuleNode = "",
Bank = bank,
Weapon = game.AssetDatabase.Weapons.First <LogicalWeapon>((Func <LogicalWeapon, bool>)(weapon => string.Equals(weapon.WeaponName, weaponName, StringComparison.InvariantCultureIgnoreCase))),
DesignID = weaponBankInfo == null || !weaponBankInfo.DesignID.HasValue ? 0 : weaponBankInfo.DesignID.Value,
InitialTargetFilter = new int?(weaponBankInfo.FilterMode ?? 0),
InitialFireMode = new int?(weaponBankInfo.FiringMode ?? 0)
};
weaponAssignmentList.Add(weaponAssignment);
flag = true;
}
if (!flag && !string.IsNullOrEmpty(bank.DefaultWeaponName))
{
WeaponAssignment weaponAssignment = new WeaponAssignment()
{
ModuleNode = "",
Bank = bank,
Weapon = game.AssetDatabase.Weapons.First <LogicalWeapon>((Func <LogicalWeapon, bool>)(weapon => string.Equals(weapon.WeaponName, bank.DefaultWeaponName, StringComparison.InvariantCultureIgnoreCase))),
DesignID = weaponBankInfo == null || !weaponBankInfo.DesignID.HasValue ? 0 : weaponBankInfo.DesignID.Value
};
weaponAssignmentList.Add(weaponAssignment);
}
}
foreach (LogicalModuleMount module in shipSectionAsset.Modules)
{
LogicalModuleMount sectionModule = module;
DesignModuleInfo designModuleInfo = sectionInfo.Modules.FirstOrDefault <DesignModuleInfo>((Func <DesignModuleInfo, bool>)(x => x.MountNodeName == sectionModule.NodeName));
if (designModuleInfo != null)
{
string path = game.GameDatabase.GetModuleAsset(designModuleInfo.ModuleID);
LogicalModule logicalModule = game.AssetDatabase.Modules.FirstOrDefault <LogicalModule>((Func <LogicalModule, bool>)(x => x.ModulePath == path));
moduleAssignmentList.Add(new ModuleAssignment()
{
ModuleMount = sectionModule,
Module = logicalModule
});
if (designModuleInfo.WeaponID.HasValue)
{
string weaponPath = game.GameDatabase.GetWeaponAsset(designModuleInfo.WeaponID.Value);
WeaponAssignment weaponAssignment = new WeaponAssignment()
{
ModuleNode = designModuleInfo.MountNodeName,
Bank = logicalModule.Banks[0],
Weapon = game.AssetDatabase.Weapons.First <LogicalWeapon>((Func <LogicalWeapon, bool>)(x => x.FileName == weaponPath)),
DesignID = 0
};
weaponAssignmentList.Add(weaponAssignment);
}
}
}
}
ShipSectionAsset missionSection = shipSectionAssetList.FirstOrDefault <ShipSectionAsset>((Func <ShipSectionAsset, bool>)(x => x.Type == ShipSectionType.Mission));
Faction faction = game.AssetDatabase.Factions.First <Faction>((Func <Faction, bool>)(x => missionSection.Faction == x.Name));
Player playerObject = game.Game.GetPlayerObject(designInfo.PlayerID);
Subfaction subfaction = faction.Subfactions[Math.Min(playerObject.SubfactionIndex, faction.Subfactions.Length - 1)];
return(new CreateShipDummyParams()
{
ShipID = shipInfo.ID,
PreferredMount = Ship.GetPreferredMount(game, playerObject, faction, shipSectionAssetList),
ShipFaction = faction,
Sections = (IEnumerable <ShipSectionAsset>)shipSectionAssetList.ToArray(),
AssignedModules = (IEnumerable <ModuleAssignment>)moduleAssignmentList.ToArray(),
PreferredModules = game.AssetDatabase.Modules.Where <LogicalModule>((Func <LogicalModule, bool>)(x => modules.Contains <string>(x.ModuleName))),
AssignedWeapons = (IEnumerable <WeaponAssignment>)weaponAssignmentList.ToArray(),
PreferredWeapons = game.AssetDatabase.Weapons.Where <LogicalWeapon>((Func <LogicalWeapon, bool>)(x => weapons.Contains <string>(x.Name)))
});
}
public void Dispose()
{
this._attachment = (LogicalModuleMount)null;
this._module = (LogicalModule)null;
this._section = (Section)null;
}
public ShipDummy(App game, CreateShipDummyParams dummyParams)
{
this.ShipID = dummyParams.ShipID;
this._checkStatusBootstrapped = false;
this._shipClass = dummyParams.Sections.First <ShipSectionAsset>().Class;
ShipSectionAsset shipSectionAsset = dummyParams.Sections.FirstOrDefault <ShipSectionAsset>((Func <ShipSectionAsset, bool>)(x => x.Type == ShipSectionType.Mission));
ShipDummy.ShipDummyPart shipDummyPart1 = new ShipDummy.ShipDummyPart();
shipDummyPart1.Model = game.AddObject <StaticModel>((object)Ship.FixAssetNameForDLC(shipSectionAsset.ModelName, dummyParams.PreferredMount));
shipDummyPart1.IsSection = true;
this._dummyParts.Add(shipDummyPart1);
this._objects.Add((IGameObject)shipDummyPart1.Model);
foreach (ShipSectionAsset section in dummyParams.Sections)
{
ShipDummy.ShipDummyPart sectionPart = shipDummyPart1;
if (section != shipSectionAsset)
{
ShipDummy.ShipDummyPart shipDummyPart2 = new ShipDummy.ShipDummyPart();
shipDummyPart2.Model = game.AddObject <StaticModel>((object)Ship.FixAssetNameForDLC(section.ModelName, dummyParams.PreferredMount));
shipDummyPart2.AttachedModel = (IGameObject)shipDummyPart1.Model;
shipDummyPart2.AttachedNodeName = section.Type.ToString();
shipDummyPart2.IsSection = true;
this._dummyParts.Add(shipDummyPart2);
this._objects.Add((IGameObject)shipDummyPart2.Model);
sectionPart = shipDummyPart2;
}
for (int index = 0; index < section.Banks.Length; ++index)
{
LogicalBank bank = section.Banks[index];
this.AddTurretsToShipDummy(game, dummyParams.PreferredMount, dummyParams.ShipFaction, section, sectionPart, dummyParams.AssignedWeapons, dummyParams.PreferredWeapons, game.AssetDatabase.Weapons, game.AssetDatabase.TurretHousings, (LogicalModule)null, (ShipDummy.ShipDummyPart)null, bank);
}
for (int sectionModuleMountIndex = 0; sectionModuleMountIndex < section.Modules.Length; ++sectionModuleMountIndex)
{
LogicalModuleMount moduleMount = section.Modules[sectionModuleMountIndex];
if (dummyParams.AssignedModules != null)
{
LogicalModule module = (LogicalModule)null;
ModuleAssignment moduleAssignment = dummyParams.AssignedModules.FirstOrDefault <ModuleAssignment>((Func <ModuleAssignment, bool>)(x => x.ModuleMount == moduleMount));
if (moduleAssignment != null)
{
module = moduleAssignment.Module;
}
if (module == null)
{
module = LogicalModule.EnumerateModuleFits(dummyParams.PreferredModules, section, sectionModuleMountIndex, false).FirstOrDefault <LogicalModule>();
}
if (module != null)
{
ShipDummy.ShipDummyPart modulePart = new ShipDummy.ShipDummyPart();
modulePart.Model = game.AddObject <StaticModel>((object)module.ModelPath);
modulePart.AttachedModel = (IGameObject)sectionPart.Model;
modulePart.AttachedNodeName = moduleMount.NodeName;
this._dummyParts.Add(modulePart);
this._objects.Add((IGameObject)modulePart.Model);
for (int index = 0; index < module.Banks.Length; ++index)
{
LogicalBank bank = module.Banks[index];
this.AddTurretsToShipDummy(game, dummyParams.PreferredMount, dummyParams.ShipFaction, section, sectionPart, dummyParams.AssignedWeapons, dummyParams.PreferredWeapons, game.AssetDatabase.Weapons, game.AssetDatabase.TurretHousings, module, modulePart, bank);
}
}
}
}
}
this._objects.Add((IGameObject)game.AddObject <RigidBody>((object)1f, (object)false));
}
