public void TestEngineComponentFactory()
{
ComponentTemplateSD engine = EngineComponentSD();
ComponentDesign design = GenericComponentFactory.StaticToDesign(engine, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
foreach (var ability in design.ComponentDesignAttributes)
{
if (ability.GuiHint == GuiHint.GuiTechSelectionList)
{
List <Guid> selectionlist = ability.GuidDictionary.Keys.Cast <Guid>().ToList();
ability.SetValueFromGuidList(selectionlist[selectionlist.Count - 1]);
}
else if (ability.GuiHint == GuiHint.GuiSelectionMaxMin)
{
ability.SetMax();
ability.SetValueFromInput(ability.MaxValue);
}
else
{
ability.SetValue();
}
}
design.ComponentDesignAttributes[0].SetValueFromInput(250);
Entity engineEntity = GenericComponentFactory.DesignToDesignEntity(_game, _faction, design);
Assert.AreEqual(250, engineEntity.GetDataBlob <ComponentInfoDB>().SizeInTons);
Dictionary <Guid, ComponentTemplateSD> componentsDict = new Dictionary <Guid, ComponentTemplateSD>();
componentsDict.Add(engine.ID, engine);
StaticDataManager.ExportStaticData(componentsDict, "EngineComponentTest.json");
}
public void TestShipCreation()
{
ComponentDesign engineDesign;
_engineSD = _game.StaticData.ComponentTemplates[new Guid("E76BD999-ECD7-4511-AD41-6D0C59CA97E6")];
engineDesign = GenericComponentFactory.StaticToDesign(_engineSD, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
engineDesign.ComponentDesignAbilities[0].SetValueFromInput(5); //size = 25 power.
//engineDesignDB.ComponentDesignAbilities[1]
_engineComponent = GenericComponentFactory.DesignToDesignEntity(_game, _faction, engineDesign);
_shipClass = ShipFactory.CreateNewShipClass(_game, _faction, "Ob'enn dropship");
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponent);
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponent);
Vector4 pos = new Vector4(0, 0, 0, 0);
_ship = ShipFactory.CreateShip(_shipClass, _starSystem.SystemManager, _faction, pos, _starSystem, "Serial Peacemaker");
PropulsionDB propulsion = _ship.GetDataBlob <PropulsionDB>();
ShipInfoDB shipInfo = _ship.GetDataBlob <ShipInfoDB>();
//Change in component cloning makes the next line's assumption untrue
//Assert.True(_ship.GetDataBlob<ComponentInstancesDB>().SpecificInstances.ContainsKey(_engineComponent));
Assert.AreEqual(50, propulsion.TotalEnginePower);
Assert.AreEqual(ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, _ship.GetDataBlob <ShipInfoDB>().Tonnage), propulsion.MaximumSpeed);
EntityManipulation.AddComponentToEntity(_ship, _engineComponent);
Assert.AreEqual(75, propulsion.TotalEnginePower);
Assert.AreEqual(ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, _ship.GetDataBlob <ShipInfoDB>().Tonnage), propulsion.MaximumSpeed);
}
public static void Import()
{
Dictionary <string, GenericComponent> components = new Dictionary <string, GenericComponent>();
string[] lines = System.IO.File.ReadAllLines("Resources/circuit1.txt");
bool linking = false;
foreach (string line in lines)
{
if (!line.StartsWith("#"))
{
if (String.IsNullOrWhiteSpace(line))
{
linking = true;
}
else
{
if (!linking)
{
string[] strings = line.Split(':');
string name = strings[0].Trim();
string type = strings[1].Trim();
type = type.Replace(";", "");
GenericComponent component = GenericComponentFactory.CreateComponent(type);
components.Add(name, component);
}
else
{
string[] strings = line.Split(':');
string componentName = strings[0].Trim();
string outputString = strings[1].Trim();
outputString = outputString.Replace(";", "");
string[] outputList = outputString.Split(',');
GenericComponent source = components[componentName];
foreach (string target in outputList)
{
components[target].addInput(source);
}
}
}
}
}
/*foreach(KeyValuePair<string,GenericComponent> kv in components)
* {
* if (kv.Value is Source)
* {
* kv.Value.Trigger();
* }
* }
* foreach (KeyValuePair<string, GenericComponent> kv in components)
* {
* Console.WriteLine(kv.Key + " " + kv.Value.state);
* }*/
}
public void SetComponent(Guid componentGuid)
{
ComponentTemplateSD componentSD = _staticData.ComponentTemplates[componentGuid];
Design = GenericComponentFactory.StaticToDesign(componentSD, _factionTech, _staticData);
AbilityList = new List <ComponentAbilityDesignVM>();
foreach (var componentAbility in Design.ComponentDesignAbilities)
{
AbilityList.Add(new ComponentAbilityDesignVM(this, componentAbility, _staticData));
}
}
public void CreateComponents(string componentLine)
{
string[] strings = componentLine.Split(':');
string name = strings[0].Trim();
string type = strings[1].Trim();
type = type.Replace(";", "");
GenericComponent component = GenericComponentFactory.CreateComponent(type);
components.Add(name, component);
}
public void TestMineInstalationFactory()
{
ComponentTemplateSD mine = MineInstallation();
ComponentDesign mineDesign = GenericComponentFactory.StaticToDesign(mine, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
mineDesign.ComponentDesignAttributes[0].SetValue();
Entity mineEntity = GenericComponentFactory.DesignToDesignEntity(_game, _faction, mineDesign);
Assert.AreEqual(10, mineEntity.GetDataBlob <MineResourcesAtbDB>().ResourcesPerEconTick.Values.ElementAt(0));
Dictionary <Guid, ComponentTemplateSD> componentsDict = new Dictionary <Guid, ComponentTemplateSD>();
componentsDict.Add(mine.ID, mine);
StaticDataManager.ExportStaticData(componentsDict, "MineComponentTest.json");
}
public void TestFactoryComponentCreation()
{
ComponentTemplateSD factory = Factory();
ComponentDesign facDesign = GenericComponentFactory.StaticToDesign(factory, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
facDesign.ComponentDesignAttributes[0].SetValue();
Entity facDesignEntity = GenericComponentFactory.DesignToDesignEntity(_game, _faction, facDesign);
ConstructionAtbDB attributeDB = facDesignEntity.GetDataBlob <ConstructionAtbDB>();
Assert.AreEqual(100, attributeDB.ConstructionPoints[ConstructionType.ShipComponents]);
Dictionary <Guid, ComponentTemplateSD> componentsDict = new Dictionary <Guid, ComponentTemplateSD>();
componentsDict.Add(factory.ID, factory);
StaticDataManager.ExportStaticData(componentsDict, "FactoryComponentTest.json");
}
public void TestShipCreation()
{
ComponentDesign engineDesign;// = DefaultStartFactory.DefaultEngineDesign(_game, _faction);
_engineSD = NameLookup.GetTemplateSD(_game, "Engine");
engineDesign = GenericComponentFactory.StaticToDesign(_engineSD, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
engineDesign.ComponentDesignAttributes[0].SetValueFromInput(5); //size = 25 power.
_engineComponentDesign = GenericComponentFactory.DesignToDesignEntity(_game, _faction, engineDesign);
_shipClass = ShipFactory.CreateNewShipClass(_game, _faction, "Ob'enn dropship");
Assert.True(_shipClass.FactionOwner == _faction.Guid);
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponentDesign);
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponentDesign);
Vector3 pos = new Vector3(0, 0, 0);
int designEngineNumber = _shipClass.GetDataBlob <ComponentInstancesDB>().GetNumberOfComponentsOfDesign(_engineComponentDesign.Guid);
Assert.AreEqual(2, designEngineNumber);
_ship = ShipFactory.CreateShip(_shipClass, _starSystem, _faction, pos, _starSystem, "Serial Peacemaker");
Assert.AreEqual(designEngineNumber, _ship.GetDataBlob <ComponentInstancesDB>().GetNumberOfComponentsOfDesign(_engineComponentDesign.Guid), "Number of engine components not the same as design");
PropulsionAbilityDB propulsion = _ship.GetDataBlob <PropulsionAbilityDB>();
ShipInfoDB shipInfo = _ship.GetDataBlob <ShipInfoDB>();
Assert.AreEqual(500000, propulsion.TotalEnginePower, "Incorrect TotalEnginePower");
float tonnage1 = _ship.GetDataBlob <ShipInfoDB>().Tonnage;
int expectedSpeed1 = ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, tonnage1);
Assert.AreEqual(expectedSpeed1, propulsion.MaximumSpeed_MS, "Incorrect Max Speed");
EntityManipulation.AddComponentToEntity(_ship, _engineComponentDesign); //add second engine
Assert.AreEqual(750000, propulsion.TotalEnginePower, "Incorrect TotalEnginePower 2nd engine added");
float tonnage2 = _ship.GetDataBlob <ShipInfoDB>().Tonnage;
int expectedSpeed2 = ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, tonnage2);
Assert.AreEqual(expectedSpeed2, propulsion.MaximumSpeed_MS, "Incorrect Max Speed 2nd engine");
}
public void TestCargoComponentCreation()
{
ComponentTemplateSD cargo = GeneralCargo();
ComponentDesign cargoDesign = GenericComponentFactory.StaticToDesign(cargo, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
cargoDesign.ComponentDesignAttributes[0].SetValue();
Entity cargoEntity = GenericComponentFactory.DesignToDesignEntity(_game, _faction, cargoDesign);
CargoStorageAtbDB attributeDB = cargoEntity.GetDataBlob <CargoStorageAtbDB>();
CargoTypeSD cargotype = _game.StaticData.CargoTypes[attributeDB.CargoTypeGuid];
Assert.AreEqual(100, attributeDB.StorageCapacity);
Dictionary <Guid, ComponentTemplateSD> componentsDict = new Dictionary <Guid, ComponentTemplateSD>();
componentsDict.Add(cargo.ID, cargo);
StaticDataManager.ExportStaticData(componentsDict, "CargoComponentTest.json");
}
public void Init()
{
_game = new TestGame();
StaticDataManager.LoadData("Pulsar4x", _game.Game); // TODO: Figure out correct directory
_entityManager = _game.Game.GlobalManager;
// Initialize gas dictionary - haven't found a good way to look up gases without doing this
_gasDictionary = new Dictionary <string, AtmosphericGasSD>();
foreach (WeightedValue <AtmosphericGasSD> atmos in _game.Game.StaticData.AtmosphericGases)
{
_gasDictionary.Add(atmos.Value.ChemicalSymbol, atmos.Value);
}
_planetsList = new List <Entity>();
_planetsList.Add(_game.Earth);
_speciesList = new List <Entity>();
_speciesList.Add(_game.HumanSpecies);
//_speciesList.Add(_game.GreyAlienSpecies);
// Set up colonies
// @todo: add more colonies, especially ones with multiple species in one colony
ComponentTemplateSD infrastructureSD = _game.Game.StaticData.ComponentTemplates[new Guid("08b3e64c-912a-4cd0-90b0-6d0f1014e9bb")];
ComponentDesign infrastructureDesign = GenericComponentFactory.StaticToDesign(infrastructureSD, _game.HumanFaction.GetDataBlob <FactionTechDB>(), _game.Game.StaticData);
Entity infrastructureEntity = GenericComponentFactory.DesignToDesignEntity(_game.Game, _game.HumanFaction, infrastructureDesign);
EntityManipulation.AddComponentToEntity(_game.EarthColony, infrastructureEntity);
ReCalcProcessor.ReCalcAbilities(_game.EarthColony);
}
public void CreateComponent()
{
GenericComponentFactory.DesignToDesignEntity(_gameVM.Game, _factionEntity, Design);
}
private void testPlanetAndSpecies(Entity planet, Entity species)
{
long[] basePop = new long[] { 0, 5, 10, 100, 999, 1000, 10000, 100000, 10000000 };
long[] infrastructureAmounts = new long[] { 0, 1, 5, 100 };
Dictionary <Entity, long> newPop, returnedPop;
int i, j, k;
Guid infGUID = new Guid("08b3e64c-912a-4cd0-90b0-6d0f1014e9bb");
ComponentTemplateSD infrastructureSD = _game.Game.StaticData.ComponentTemplates[infGUID];
ComponentDesign infrastructureDesign = GenericComponentFactory.StaticToDesign(infrastructureSD, _game.HumanFaction.GetDataBlob <FactionTechDB>(), _game.Game.StaticData);
Entity infrastructureEntity = GenericComponentFactory.DesignToDesignEntity(_game.Game, _game.HumanFaction, infrastructureDesign);
Dictionary <Entity, long> pop = _game.EarthColony.GetDataBlob <ColonyInfoDB>().Population;
// Single iteration growth test
for (i = 0; i < infrastructureAmounts.Length; i++)
{
// Create a new colony with this planet and species, add infrastructure item to it
_game.EarthColony = ColonyFactory.CreateColony(_game.HumanFaction, species, planet);
// Add the correct number of infrastructure to the colony
for (k = 0; k < infrastructureAmounts[i]; k++)
{
EntityManipulation.AddComponentToEntity(_game.EarthColony, infrastructureEntity);
}
ReCalcProcessor.ReCalcAbilities(_game.EarthColony);
for (j = 0; j < basePop.Length; j++)
{
// set up population and infrastructure for each test
newPop = _game.EarthColony.GetDataBlob <ColonyInfoDB>().Population;
foreach (KeyValuePair <Entity, long> kvp in newPop.ToArray())
{
newPop[kvp.Key] = basePop[j];
}
//var infrastuctures = _game.EarthColony.GetDataBlob<ComponentInstancesDB>().SpecificInstances[infrastructureEntity].Where(inf => inf.DesignEntity.HasDataBlob<LifeSupportAbilityDB>());
returnedPop = calcGrowthIteration(_game.EarthColony, newPop);
PopulationProcessor.GrowPopulation(_game.EarthColony);
foreach (KeyValuePair <Entity, long> kvp in pop.ToArray())
{
Assert.AreEqual(returnedPop[kvp.Key], pop[kvp.Key]);
}
}
}
// Multiple iteration growth test
for (i = 0; i < infrastructureAmounts.Length; i++)
{
// Create a new colony with this planet and species, add infrastructure item to it
_game.EarthColony = ColonyFactory.CreateColony(_game.HumanFaction, species, planet);
// Add the correct number of infrastructure to the colony
for (k = 0; k < infrastructureAmounts[i]; k++)
{
EntityManipulation.AddComponentToEntity(_game.EarthColony, infrastructureEntity);
}
ReCalcProcessor.ReCalcAbilities(_game.EarthColony);
for (j = 0; j < basePop.Length; j++)
{
// set up population and infrastructure for each test
newPop = _game.EarthColony.GetDataBlob <ColonyInfoDB>().Population;
foreach (KeyValuePair <Entity, long> kvp in newPop.ToArray())
{
newPop[kvp.Key] = basePop[j];
}
for (k = 0; k < 10; k++)
{
newPop = calcGrowthIteration(_game.EarthColony, newPop);
PopulationProcessor.GrowPopulation(_game.EarthColony);
}
foreach (KeyValuePair <Entity, long> kvp in pop.ToArray())
{
Assert.AreEqual(newPop[kvp.Key], pop[kvp.Key]);
}
}
}
}
