private void Deserialized(StreamingContext context)
{
var game = (Game)context.Context;
ItemToTypeMap = game.StaticData.StorageTypeMap;
_staticData = game.StaticData;
}
/// <summary>
/// Primary Constructor for ComponentDesignDB
/// </summary>
/// <param name="expressionString"></param>
/// <param name="design"></param>
/// <param name="factionTech"></param>
/// <param name="staticDataStore"></param>
internal ChainedExpression(string expressionString, ComponentDesign design, FactionTechDB factionTech, StaticDataStore staticDataStore)
{
_staticDataStore = staticDataStore;
_factionTechDB = factionTech;
_design = design;
ReplaceExpression(expressionString);
}
public ColonyScreenVM(GameVM gameVM, Entity colonyEntity, StaticDataStore staticData)
{
gameVM.Game.GameLoop.GameGlobalDateChangedEvent += GameVM_DateChangedEvent;
_colonyEntity = colonyEntity;
_facilities = new ObservableCollection <FacilityVM>();
ComponentInstancesDB instaces = colonyEntity.GetDataBlob <ComponentInstancesDB>();
foreach (var installation in instaces.SpecificInstances)
{
//Facilities.Add(new FacilityVM(installation.Key, instaces));
FacilitesList.Add(new ComponentSpecificDesignVM(installation.Key, installation.Value));
}
UpdatePop();
CommandReferences cmdRef = new CommandReferences(FactionEntity.Guid, _colonyEntity.Guid, gameVM.Game.OrderHandler, _colonyEntity.Manager.ManagerSubpulses);
CargoStoreVM = new CargoStorageVM(staticData, cmdRef, colonyEntity.GetDataBlob <CargoStorageDB>());
PlanetMineralDepositVM = new PlanetMineralDepositVM(staticData, _colonyEntity.GetDataBlob <ColonyInfoDB>().PlanetEntity);
RefineryAbilityVM = new RefineryAbilityVM(staticData, _colonyEntity);
ConstructionAbilityVM = new ConstructionAbilityVM(staticData, _colonyEntity);
ColonyResearchVM = new ColonyResearchVM(staticData, _colonyEntity);
}
public ColonyResearchVM(StaticDataStore staticData, Entity colonyEntity)
{
//_factionEntity;// = colonyEntity.GetDataBlob<OwnedDB>().OwnedByFaction;
colonyEntity.Manager.FindEntityByGuid(colonyEntity.FactionOwner, out _factionEntity);
_colonyEntity = colonyEntity;
_factionTech = _factionEntity.GetDataBlob <FactionTechDB>();
Scientists = new List <ScientistControlVM>();
if (_factionTech.ResearchableTechs.Count > 0)
{
//ResearchableTechs = new ObservableCollection<TechSD>(_factionTech.ResearchableTechs.Keys);
ResearchableTechs = new DictionaryVM <TechSD, string>(DisplayMode.Value);
foreach (var tech in _factionTech.ResearchableTechs.Keys)
{
ResearchableTechs.Add(tech, tech.Name);
}
SelectedTechIndex = 0;
}
foreach (var scientist in _colonyEntity.GetDataBlob <ColonyInfoDB>().Scientists)
{
Scientists.Add(new ScientistControlVM(staticData, _factionTech, scientist));
}
SelectedScientist = Scientists[0];
Refresh();
}
public CargoStorageVM(StaticDataStore staticData, CommandReferences cmdRef, CargoStorageDB storeDB)
{
_staticData = staticData;
_storageDatablob = storeDB;
CmdRef = cmdRef;
Update();
}
internal ChainedExpression(string expressionString, ComponentDesigner designer, FactionTechDB factionTech)
{
_staticDataStore = StaticRefLib.StaticData;
_factionTechDB = factionTech;
_designer = designer;
ReplaceExpression(expressionString);
}
/// <summary>
/// Checks for a valid vinfo file in the specified directory, if the file is found it loads it and
/// checks that it is compatible with previously loaded data and the library.
/// </summary>
/// <param name="directory">Directory to check.</param>
/// <param name="staticDataStore">staticDataStore to check this dataVersionInfo against loaded dataVersionInfo for incompatibilities</param>
/// <param name="dataVInfo">Static data version to check against.</param>
/// <returns>true if a compatible vinfo file was found, false otherwise.</returns>
private static bool CheckDataDirectoryVersion(string directory, StaticDataStore staticDataStore, out DataVersionInfo dataVInfo)
{
dataVInfo = null;
string[] vInfoFile = Directory.GetFiles(directory, "*.vinfo");
if (vInfoFile.GetLength(0) < 1 || string.IsNullOrEmpty(vInfoFile[0]))
{
return(false);
}
dataVInfo = LoadVinfo(vInfoFile[0]);
if (!dataVInfo.IsCompatibleWithLibrary())
{
return(false);
}
foreach (DataVersionInfo dataVersionInfo in staticDataStore.LoadedDataSets)
{
if (!dataVersionInfo.IsCompatibleWithDataset(dataVInfo))
{
return(false);
}
}
return(true);
}
public static StaticDataStore GetStaticData(string dataDir)
{
StaticDataStore newStore = new StaticDataStore();//.Clone();
string curFileName = "";
JObject obj;
//try
{
string dataDirectory = Path.Combine(Path.Combine(SerializationManager.GetWorkingDirectory(), DataDirectory), dataDir);
// we start by looking for a version file, no version file, no load.
// now we can move on to looking for json files:
string[] jsonfiles = Directory.GetFiles(dataDirectory, "*.json");
string[] hjsonfiles = Directory.GetFiles(dataDirectory, "*.hjson");
if (jsonfiles.GetLength(0) < 1 && hjsonfiles.GetLength(0) < 1)
{
return(null);
}
foreach (string file in jsonfiles)
{
curFileName = file;
obj = Load(file);
StoreObject(obj, newStore);
}
foreach (string file in hjsonfiles)
{
curFileName = file;
obj = Load(file);
StoreObject(obj, newStore);
}
//Test the components formula for parsability
List <Guid> badComponents = new List <Guid>();
foreach (var componentKVP in newStore.ComponentTemplates)
{
if (!ComponentParseCheck.IsParseable(componentKVP.Value, out var errors))
{
badComponents.Add(componentKVP.Key);
foreach (var error in errors)
{
StaticRefLib.EventLog.AddEvent(Event.NewComponentParseError(componentKVP.Value.Name, error));
}
}
}
foreach (var componentID in badComponents)
{
newStore.ComponentTemplates.Remove(componentID);
}
}
return(newStore);
}
public TechListVM(DictionaryVM <Guid, string> selectedItems, StaticDataStore staticData) : this(staticData)
{
SelectedItems = selectedItems;
foreach (var item in SelectedItems)
{
PossibleItems.Remove(item.Key);
}
}
internal RefineJobVM(RefiningVM parentVM, StaticDataStore staticData, RefineingJob job, CommandReferences cmdRef)
{
_parent = parentVM;
_staticData = staticData;
JobItem = job;
Item = _staticData.ProcessedMaterials[JobItem.ItemGuid].Name;
_cmdRef = cmdRef;
}
/// <summary>
/// a private constructor that is used internaly for a one use Expression
/// </summary>
/// <param name="expression"></param>
/// <param name="design"></param>
/// <param name="factionTech"></param>
/// <param name="staticDataStore"></param>
private ChainedExpression(Expression expression, ComponentDesign design, FactionTechDB factionTech, StaticDataStore staticDataStore)
{
_staticDataStore = staticDataStore;
_factionTechDB = factionTech;
_design = design;
_expression = expression;
SetupExpression();
}
internal RefineJobVM(RefiningVM parentVM, StaticDataStore staticData, RefineingJob job, CommandReferences cmdRef)
{
_parent = parentVM;
_staticData = staticData;
JobItem = job;
Item = _staticData.CargoGoods.GetMaterial(JobItem.ItemGuid).Name;
_cmdRef = cmdRef;
}
/// <summary>
/// Primary Constructor for ComponentDesignAbilityDB
/// </summary>
/// <param name="expressionString"></param>
/// <param name="designAbility"></param>
/// <param name="factionTech"></param>
/// <param name="staticDataStore"></param>
internal ChainedExpression(string expressionString, ComponentDesignAbility designAbility, FactionTechDB factionTech, StaticDataStore staticDataStore)
{
_staticDataStore = staticDataStore;
_factionTechDB = factionTech;
_design = designAbility.ParentComponent;
_designAbility = designAbility;
ReplaceExpression(expressionString);
}
private void GetItemsToTransfer(StaticDataStore staticData)
{
foreach (var tup in ItemsGuidsToTransfer)
{
//(ICargoable)game.StaticData.FindDataObjectUsingID(ItemToTransfer);
ItemICargoablesToTransfer.Add(new Tuple <ICargoable, long>(staticData.GetICargoable(tup.Item1), tup.Item2));
}
}
/// <summary>
/// a private constructor that is used internaly for a one use Expression
/// </summary>
/// <param name="expression"></param>
/// <param name="designAbility"></param>
/// <param name="factionTech"></param>
/// <param name="staticDataStore"></param>
private ChainedExpression(Expression expression, ComponentDesignAbility designAbility, FactionTechDB factionTech, StaticDataStore staticDataStore)
{
_staticDataStore = staticDataStore;
_factionTechDB = factionTech;
_design = designAbility.ParentComponent;
_designAbility = designAbility;
_expression = expression;
SetupExpression();
}
public ScientistControlVM(StaticDataStore staticData, FactionTechDB factionTech, Entity scientist)
{
_staticData = staticData;
_factionTech = factionTech;
ScientistEntity = scientist;
_projectQueue = new ObservableCollection <ResearchTechControlVM>();
Refresh();
}
public TechListVM(StaticDataStore staticData)
{
SelectedItems = new DictionaryVM <Guid, string>();
PossibleItems = new DictionaryVM <Guid, string>();
foreach (var item in staticData.Techs.Values)
{
PossibleItems.Add(item.ID, item.Name);
}
}
public MineralFormulaVM(ComponentTemplateParentVM parent, StaticDataStore staticDataStore) : base(parent)
{
_dataStore = staticDataStore;
Minerals = new DictionaryVM <Guid, string>(DisplayMode.Value);
foreach (var item in staticDataStore.Minerals.Values)
{
Minerals.Add(item.ID, item.Name);
}
}
public JobAbilityBaseVM(StaticDataStore staticData, Entity colonyEntity)
{
//JobChangePriorityCommand = new JobPriorityCommand<TDataBlob, TJob>(this);
_staticData_ = staticData;
_colonyEntity_ = colonyEntity;
_jobCollectionSyncher = new MVMCollectionSyncher <TJob>(DataBlob.JobBatchList);
_jobCollectionSyncher.CollectionChanged += _jobCollectionSyncher_CollectionChanged;
SetupJobs();
}
public RefineryAbilityVM(StaticDataStore staticData, Entity colonyEntity) : base(staticData, colonyEntity)
{
ItemDictionary = new DictionaryVM <Guid, string>(DisplayMode.Value);
foreach (var kvp in _staticData_.ProcessedMaterials)
{
ItemDictionary.Add(kvp.Key, kvp.Value.Name);
}
//NewJobSelectedItem = ItemDictionary[ItemDictionary.ElementAt(0).Key];
NewJobSelectedIndex = 0;
NewJobBatchCount = 1;
NewJobRepeat = false;
}
/// <summary>
/// Constructor for empty VM
/// </summary>
/// <param name="parent"></param>
/// <param name="gameVM"></param>
public ComponentTemplateMainPropertiesVM(ComponentTemplateParentVM parent, GameVM gameVM) : base(parent)
{
_staticData = gameVM.Game.StaticData;
SubControlInFocus = FocusedControl.MassControl;
foreach (var item in Enum.GetValues(typeof(ComponentMountType)))
{
if ((ComponentMountType)item != ComponentMountType.None)
{
MountType.Add((ComponentMountType)item, false);
}
}
}
internal CargoTypeStoreVM(StaticDataStore staticDataStore, Guid typeGuid, CargoTypeStore typeStore)
{
_staticData = staticDataStore;
_typeStore = typeStore;
var _cargoTypeSD = staticDataStore.CargoTypes[typeGuid];
StorageTypeName = _cargoTypeSD.Name;
StorageTypeDescription = _cargoTypeSD.Description;
Update();
}
public ConstructionAbilityVM(StaticDataStore staticData, Entity colonyEntity) : base(staticData, colonyEntity)
{
ItemDictionary = new DictionaryVM <Guid, string>(DisplayMode.Value);
foreach (var kvp in _factionInfo.ComponentDesigns)
{
ItemDictionary.Add(kvp.Key, kvp.Value.Name);
}
//NewJobSelectedItem = ItemDictionary.SelectedKey;
NewJobSelectedIndex = 0;
NewJobBatchCount = 1;
NewJobRepeat = false;
}
/// <summary>
/// adds abilites to a ship or component instance
/// </summary>
/// <param name="shipOrColony"></param>
/// <param name="componentDesign"></param>
/// <param name="componentInstance"></param>
internal static void AddAbility(Entity shipOrColony, Entity componentDesign, Entity componentInstance)
{
_staticDataStore = shipOrColony.Manager.Game.StaticData;
foreach (var datablob in componentDesign.DataBlobs)
{
var t = datablob.GetType();
if (TypeMap.ContainsKey(t))
{
TypeMap[t].DynamicInvoke(shipOrColony, componentInstance); // invoke appropriate delegate
}
}
componentInstance.GetDataBlob <ComponentInstanceInfoDB>().ParentEntity = shipOrColony;
}
public static void AddJob(StaticDataStore staticData, Entity colonyEntity, RefineingJob job)
{
ColonyRefiningDB refiningDB = colonyEntity.GetDataBlob <ColonyRefiningDB>();
lock (refiningDB.JobBatchList) //prevent threaded race conditions
{
//check if the job materialguid is valid, then add it if so.
if (staticData.ProcessedMaterials.ContainsKey(job.ItemGuid))
{
refiningDB.JobBatchList.Add(job);
}
}
}
internal override bool IsValidCommand(Game game)
{
_staticData = game.StaticData;
if (CommandHelpers.IsCommandValid(game.GlobalManager, RequestingFactionGuid, EntityCommandingGuid, out _factionEntity, out _entityCommanding))
{
if (_staticData.ProcessedMaterials.ContainsKey(MaterialGuid))
{
int pointCost = _staticData.ProcessedMaterials[MaterialGuid].RefineryPointCost;
_job = new RefineingJob(MaterialGuid, NumberOrderd, pointCost, RepeatJob);
return(true);
}
}
return(false);
}
public ComponentDesignVM(GameVM gameVM)
{
_gameVM = gameVM;
_staticData = gameVM.Game.StaticData;
_factionEntity = gameVM.CurrentFaction;
_factionTech = gameVM.CurrentFaction.GetDataBlob <FactionTechDB>();
foreach (var componentSD in gameVM.Game.StaticData.ComponentTemplates.Values)
{
ComponentTypes.Add(componentSD.Name, componentSD.ID);
}
ComponentTypes.SelectedIndex = 0;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="gameVM"></param>
public ComponentTemplateParentVM(GameVM gameVM)
{
_staticData = gameVM.Game.StaticData;
_gameVM = gameVM;
FormulaEditor = new FormulaEditorVM(this, _staticData);
foreach (var item in _staticData.ComponentTemplates.Values)
{
Components.Add(item, item.Name);
}
SelectedComponent = new ComponentTemplateMainPropertiesVM(this, _gameVM);
Components.SelectionChangedEvent += Components_SelectionChangedEvent;
Components.SelectedIndex = 0;
}
/// <summary>
/// Stores the data in the provided JObject if it is valid.
/// </summary>
private static void StoreObject(JObject obj, StaticDataStore staticDataStore)
{
// we need to work out the type:
Type type = StaticDataStore.GetType(obj["Type"].ToString());
// grab the data:
// use dynamic here to avoid having to know/use the exact the types.
// we are alreading checking the types via StaticDataStore.*Type, so we
// can rely on there being an overload of StaticDataStore.Store
// that supports that type.
dynamic data = obj["Data"].ToObject(type, Serializer);
staticDataStore.Store(data);
}
public RefiningVM(Game game, CommandReferences cmdRef, RefiningDB refiningDB)
{
_staticData = game.StaticData;
_refineDB = refiningDB;
_orderHandler = game.OrderHandler;
_factionGuid = refiningDB.OwningEntity.FactionOwner;
_cmdRef = cmdRef;
foreach (var kvp in _staticData.CargoGoods.GetMaterials())
{
ItemDictionary.Add(kvp.Key, kvp.Value.Name);
}
ItemDictionary.SelectedIndex = 0;
NewJobBatchCount = 1;
NewJobRepeat = false;
}
