public void CalculateAverageWaterSupplyOfCanalHeadTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateRoundOrderArea();
hydroCalculator.CalculateOriginalIrrigationRequirement();
hydroCalculator.CalculateGrossIrrigationRequirement();
hydroCalculator.CalculateAverageWaterSupplyOfCanalHead();
List <double> testCase = new List <double>()
{
11634750, 2446292, 2714460, 2951257, 2735383, 2793779, 1465560, 379673, 62961444
};
List <double> roundDays = new List <double>()
{
21, 17, 21, 19, 18, 15, 19, 18, 55
};
for (int i = 0; i < testCase.Count; i++)
{
testCase[i] = testCase[i] / 0.63 / roundDays[i] / 8.64;
Console.WriteLine(testCase[i]);
Console.WriteLine(hydroCalculator.AverageWaterSupplyOfCanalHead[i]);
}
Assert.IsTrue(IsListEqual(hydroCalculator.AverageWaterSupplyOfCanalHead, testCase));
}
public ActionResult DeleteConfirmed(int id)
{
Hydro hydro = db.Hydros.Find(id);
db.Hydros.Remove(hydro);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "HydroID,Name,Price,Description")] Hydro hydro)
{
if (ModelState.IsValid)
{
db.Entry(hydro).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(hydro));
}
private Hydro InitHydro()
{
Hydro hydroCalculator = new Hydro(HydroConst.GrossIrrigationConst, HydroConst.AverageWaterSupplyOfCanalHeadConst, HydroConst.WaterRequirementConst, HydroConst.BasicUtilizableCapacity);
hydroCalculator.Inflow = InitInflowData();
hydroCalculator.DryEarth = InitDryEarthData();
hydroCalculator.DeptCropArea = InitDeptCropAreaData();
hydroCalculator.RoundOrderInfo = InitRoundOrderInfo();
hydroCalculator.IrrigationInstitution = InitIrrigationInstitution();
return(hydroCalculator);
}
public ActionResult Create([Bind(Include = "HydroID,Name,Price,Description")] Hydro hydro)
{
if (ModelState.IsValid)
{
db.Hydros.Add(hydro);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(hydro));
}
// GET: Hydro/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Hydro hydro = db.Hydros.Find(id);
if (hydro == null)
{
return(HttpNotFound());
}
return(View(hydro));
}
public void CalculateInflowAveragePredictionTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateInflowAveragePrediction();
List <double> testCase = new List <double>()
{
119.18, 68.44, 40.82, 83.412, 123.323, 140.645, 248.84, 129.02, 104.01
};
for (int i = 0; i < testCase.Count; i++)
{
testCase[i] = testCase[i] * 8.64 * 10;
Console.WriteLine(testCase[i]);
Console.WriteLine(hydroCalculator.InflowAveragePrediction[i]);
}
Assert.IsTrue(IsListEqual(testCase, hydroCalculator.InflowAveragePrediction));
}
public void CalculateGrossIrrigationRequirementTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateRoundOrderArea();
hydroCalculator.CalculateOriginalIrrigationRequirement();
hydroCalculator.CalculateGrossIrrigationRequirement();
List <double> testCase = new List <double>()
{
11634750, 2446292, 2714460, 2951257, 2735383, 2793779, 1465560, 379673, 62961444
};
for (int i = 0; i < testCase.Count; i++)
{
testCase[i] /= 0.63;
}
Assert.IsTrue(IsListEqual(hydroCalculator.GrossIrrigationRequirement, testCase));
}
public void CalculateOriginalIrrigationRequirementTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateRoundOrderArea();
hydroCalculator.CalculateOriginalIrrigationRequirement();
List <int> testCase = new List <int>()
{
11634750, 2446292, 2714460, 2951257, 2735383, 2793779, 1465560, 379673, 62961444
};
for (int i = 0; i < hydroCalculator.OriginalIrrigationRequirement.Count; i++)
{
Console.WriteLine(hydroCalculator.OriginalIrrigationRequirement[i]);
Console.WriteLine(testCase[i]);
}
Assert.IsTrue(IsListEqual(hydroCalculator.OriginalIrrigationRequirement, testCase));
}
public void CalculateRoundOrderAreaTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateRoundOrderArea();
//List<int> testCase = new List<int>() { 19964, 525, 14032, 13833, 2274, 16887, 312, 2023, 651, 1733, 1194, 2572, 6594, 5858, 10759, 11765};
List <int> testCase = new List <int>()
{
77565, 33058, 39340, 41567, 37471, 39349, 20355, 5201, 345942
};
for (int i = 0; i < hydroCalculator.RoundOrderArea.Count; i++)
{
Console.WriteLine(hydroCalculator.RoundOrderArea[i]);
Console.WriteLine(testCase[i]);
}
Assert.IsTrue(IsListEqual(hydroCalculator.RoundOrderArea, testCase));
}
public void CalculateUtilizableCapacityTest()
{
Hydro hydroCalculator = InitHydro();
hydroCalculator.CalculateRoundOrderArea();
hydroCalculator.CalculateOriginalIrrigationRequirement();
hydroCalculator.CalculateGrossIrrigationRequirement();
hydroCalculator.CalculateAverageWaterSupplyOfCanalHead();
hydroCalculator.CalculateAverageFlow();
hydroCalculator.CalculateWaterRequirement();
hydroCalculator.CalculateInflowAveragePrediction();
hydroCalculator.CalculateUtilizableCapacity();
List <double> testCase = new List <double>()
{
0, 0, 0, 0, 0, 0, 0, 0, 0
};
for (int i = 0; i < hydroCalculator.InflowAveragePrediction.Count; i++)
{
double restWater = (0 == i ? 18956.8062545455 : testCase[i - 1]);
testCase[i] = restWater + hydroCalculator.InflowAveragePrediction[i] - hydroCalculator.WaterRequirement[i];
}
Assert.IsTrue(IsListEqual(testCase, hydroCalculator.UtilizableCapacity));
}
public string UWP(Planet.WorldType type = Planet.WorldType.NORMAL, double diameter = 0)
{
var builder = new StringBuilder();
switch (type)
{
case Planet.WorldType.LGG:
builder.AppendFormat("LGG - diameter {0} km", diameter.ToString("F"));
break;
case Planet.WorldType.SGG:
builder.AppendFormat("SGG - diameter {0} km", diameter.ToString("F"));
break;
case Planet.WorldType.SMALL:
builder.AppendFormat("{0}-S{1}{2}{3}-{4}", Starport, Atmosphere.ToString(), Hydro.ToString(), SocialUWP(), TechLevel.ToString());
break;
case Planet.WorldType.RING:
builder.AppendFormat("{0}-R00{1}-{2}", Starport, SocialUWP(), TechLevel.ToString());
break;
case Planet.WorldType.NORMAL:
case Planet.WorldType.PLANETOID:
builder.AppendFormat("{0}-{1}{2}-{3}", Starport, PhysicalUWP(), SocialUWP(), TechLevel.ToString());
break;
case Planet.WorldType.STAR:
builder.Append(Languages.CompanionStar);
break;
}
return(builder.ToString());
}
public static Project Create(string Profolder, string Proname, PType Protype, bool Inctemplate)
{
Project PObject;
string Profile = Profolder + @"\" + Proname + @"\" + Proname + ".mpr";
Profolder = Profolder + @"\" + Proname;
switch (Protype)
{
case PType.Csharp:
PObject = new Csharp(Profile);
break;
case PType.Databse:
PObject = new Database(Profile);
break;
case PType.Hydro:
PObject = new Hydro(Profile);
break;
case PType.Ilasm:
PObject = new Ilasm(Profile);
break;
case PType.Java:
PObject = new Java(Profile);
break;
case PType.Unmanaged:
PObject = new Unmanaged(Profile);
break;
case PType.Vbasic:
PObject = new Vbasic(Profile);
break;
case PType.Website:
PObject = new Website(Profile);
break;
case PType.Yalamof:
PObject = new Yalamof(Profile);
break;
default:
PObject = new Unmanaged();
break;
}
try
{
Directory.CreateDirectory(Profolder);
if (Inctemplate == true)
{
PObject.CopyTemplate();
}
PObject.Save();
}
catch (Exception e)
{
Exceptioner.Log(e);
}
return(PObject);
}
private void LoadSaveLua(){
System.Text.Encoding encodeType = System.Text.Encoding.ASCII;
string loadedFileSave = "";
string MapPath = EnvPaths.GetMapsPath();
loadedFileSave = System.IO.File.ReadAllText(ScenarioData.SaveLua.Replace("/maps/", MapPath), encodeType);
string loadedFileFunctions = LuaHelper.GetStructureText ("lua_variable_functions.lua");
//loadedFileFunctions = System.IO.File.ReadAllText(StructurePath + "lua_variable_functions.lua", encodeType);
string loadedFileEndFunctions = LuaHelper.GetStructureText ("lua_variable_end_functions.lua");
//loadedFileEndFunctions = System.IO.File.ReadAllText(StructurePath + "lua_variable_end_functions.lua", encodeType);
loadedFileSave = loadedFileFunctions + loadedFileSave + loadedFileEndFunctions;
save = new Lua();
save.LoadCLRPackage();
try {
save.DoString(loadedFileSave);
} catch(NLua.Exceptions.LuaException e) {
Debug.LogError(ParsingStructureData.FormatException(e), gameObject);
HelperGui.MapLoaded = false;
return;
}
// LoadArea
ScenarioData.Area = new Rect();
if(save.GetTable("Scenario.Areas.AREA_1") != null && save.GetTable("Scenario.Areas.AREA_1").ToString() != "null"){
ScenarioData.DefaultArea = true;
ScenarioData.Area.x = float.Parse(save.GetTable("Scenario.Areas.AREA_1.rectangle")[1].ToString(), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
ScenarioData.Area.y = float.Parse(save.GetTable("Scenario.Areas.AREA_1.rectangle")[2].ToString(), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
ScenarioData.Area.width = float.Parse(save.GetTable("Scenario.Areas.AREA_1.rectangle")[3].ToString(), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
ScenarioData.Area.height = float.Parse(save.GetTable("Scenario.Areas.AREA_1.rectangle")[4].ToString(), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
UpdateArea();
}
else{
ScenarioData.DefaultArea = false;
HeightmapControler.TerrainMaterial.SetInt("_Area", ScenarioData.DefaultArea?1:0);
MapElements.SetActive(false);
HeightmapControler.TerrainMaterial.SetFloat("_AreaX", 0);
HeightmapControler.TerrainMaterial.SetFloat("_AreaY", 0);
HeightmapControler.TerrainMaterial.SetFloat("_AreaWidht", ScenarioData.Size.x / 10f);
HeightmapControler.TerrainMaterial.SetFloat("_AreaHeight", ScenarioData.Size.y / 10f);
}
MapCenterPoint = Vector3.zero;
MapCenterPoint.x = (ScenarioData.Size.x / 20);
MapCenterPoint.z = -1 * (ScenarioData.Size.y / 20);
// LoadMarkers
#region Load Markers
//int MarkersCount = save.GetTable("Scenario.MasterChain._MASTERCHAIN_.Markers").Values.Count;
Mexes = new List<Mex>();
Hydros = new List<Hydro>();
ARMY_ = new List<Army>();
SiMarkers = new List<Marker>();
//LuaTable MasterChain = save.GetTable("Scenario.MasterChain._MASTERCHAIN_.Markers") as LuaTable;
//string[] KeysArray = new string[MarkersCount];
//MasterChain.Keys.CopyTo(KeysArray, 0);
LuaHelper.LHTable MarkersTable = new LuaHelper.LHTable(save.GetTable("Scenario.MasterChain._MASTERCHAIN_.Markers"));
for(int m = 0; m < MarkersTable.Count; m++){
//LuaTable MarkerTab = MasterChain[KeysArray[m]] as LuaTable;
LuaHelper.LHTable MarkerTable = new LuaHelper.LHTable(MarkersTable, MarkersTable.Keys[m]);
Vector3 MarkerPosParsed = Vector3.zero;
MarkerTable.GetVector3Value("position", out MarkerPosParsed);
Vector3 MarkerRotParsed = Vector3.zero;
MarkerTable.GetVector3Value("orientation", out MarkerRotParsed);
string TypeOfMarker = MarkerTable.GetStringValue("type");
if(TypeOfMarker == "Mass"){
Mex newMex = new Mex();
newMex.name = MarkersTable.Keys[m];
newMex.position = HeightmapControler.MapPosInWorld(MarkerPosParsed);
newMex.orientation = MarkerRotParsed;
LuaHelper.ReadSpawnWithArmy(out newMex.SpawnWithArmy, MarkerTable);
Mexes.Add(newMex);
}
else if(TypeOfMarker == "Hydrocarbon"){
Hydro NewHydro = new Hydro();
NewHydro.name = MarkersTable.Keys[m];
NewHydro.size = MarkerTable.GetFloatValue("size");
NewHydro.amount = MarkerTable.GetFloatValue("amount");
NewHydro.resource = MarkerTable.GetBoolValue("resource");
NewHydro.prop = MarkerTable.GetStringValue("prop");
NewHydro.color = MarkerTable.GetColorValue("color");
NewHydro.position = HeightmapControler.MapPosInWorld(MarkerPosParsed);
NewHydro.orientation = MarkerRotParsed;
LuaHelper.ReadSpawnWithArmy(out NewHydro.SpawnWithArmy, MarkerTable);
Hydros.Add(NewHydro);
}
else if(MarkersTable.Keys[m].Contains("ARMY_")){
Army NewArmy = new Army();
NewArmy.name = MarkersTable.Keys[m];
NewArmy.Id = int.Parse(MarkersTable.Keys[m].Replace("ARMY_", ""));
NewArmy.position = HeightmapControler.MapPosInWorld(MarkerPosParsed);
NewArmy.orientation = MarkerRotParsed;
ARMY_.Add(NewArmy);
}
else{
Marker NewMarker = new Marker();
NewMarker.name = MarkersTable.Keys[m];
NewMarker.position = HeightmapControler.MapPosInWorld(MarkerPosParsed);
NewMarker.orientation = MarkerRotParsed;
NewMarker.type = TypeOfMarker;
NewMarker.prop = MarkerTable.GetStringValue("prop");
// HINT
NewMarker.hintValue = MarkerTable.GetStringValue("hint");
NewMarker.hint = MarkerTable.GetBoolValue("hint");
// GRAPH
NewMarker.graph = MarkerTable.GetStringValue("graph");
// adjacentTo
NewMarker.adjacentTo = MarkerTable.GetStringValue("adjacentTo");
// Color
if (!string.IsNullOrEmpty(MarkerTable.GetStringValue("color"))) {
//Color MyColor = Color.white;
//ColorUtility.TryParseHtmlString (MarkerTable.GetStringValue("color"), out MyColor);
NewMarker.Kolor = MarkerTable.GetColorValue("color");
} else
NewMarker.Kolor = Color.white;
LuaHelper.ReadSpawnWithArmy(out NewMarker.SpawnWithArmy, MarkerTable);
SiMarkers.Add(NewMarker);
}
}
SortArmys();
MexTotalCount = Mexes.Count;
HydrosTotalCount = Hydros.Count;
SiTotalCount = SiMarkers.Count;
#endregion
#region Load Army Save
SaveArmys = new List<SaveArmy> ();
LuaHelper.LHTable ArmiesTable = new LuaHelper.LHTable(save.GetTable("Scenario.Armies"));
for(int m = 0; m < ArmiesTable.Count; m++){
LuaHelper.LHTable ArmyTable = new LuaHelper.LHTable(ArmiesTable, ArmiesTable.Keys[m]);
SaveArmy NewArmy = new SaveArmy();
NewArmy.Name = ArmiesTable.Keys[m];
AddSaveArmyMarker(NewArmy.Name);
NewArmy.personality = ArmyTable.GetStringValue("personality");
NewArmy.plans = ArmyTable.GetStringValue("plans");
NewArmy.color = ArmyTable.GetIntValue("color");
NewArmy.faction = ArmyTable.GetIntValue("faction");
LuaHelper.LHTable EconomyTable = new LuaHelper.LHTable(ArmyTable, "Economy");
NewArmy.EconomyMass = EconomyTable.GetIntValue("mass");
NewArmy.EconomyEnergy = EconomyTable.GetIntValue("energy");
NewArmy.Alliances = ArmyTable.GetStringArrayValue("Alliances");
// Get units
NewArmy.UnitsOrders = "";
NewArmy.UnitsPlatoon = "";
NewArmy.Units = new List<UnitGroup>();
LuaHelper.LHTable ArmyUnitsTable;
ArmyTable.GetLuaArmyGroup("Units", out NewArmy.UnitsOrders, out NewArmy.UnitsPlatoon, out ArmyUnitsTable);
for(int i = 0; i < ArmyUnitsTable.Count; i++){
UnitGroup NewUnitGroup = new UnitGroup();
NewUnitGroup.Name = ArmyUnitsTable.Keys[i];
LuaHelper.LHTable UnitsGroupTable;
ArmyUnitsTable.GetLuaArmyGroup(ArmyUnitsTable.Keys[i], out NewUnitGroup.orders, out NewUnitGroup.platoon, out UnitsGroupTable);
for(int u = 0; u < UnitsGroupTable.Count; u++){
Unit NewUnit = new Unit();
LuaHelper.LHTable UnitTable = new LuaHelper.LHTable(UnitsGroupTable, UnitsGroupTable.Keys[u]);
NewUnit.Name = UnitsGroupTable.Keys[u];
NewUnit.type = UnitTable.GetStringValue("type");
NewUnit.orders = UnitTable.GetStringValue("orders");
NewUnit.platoon = UnitTable.GetStringValue("platoon");
UnitTable.GetVector3Value("Position", out NewUnit.Position);
UnitTable.GetVector3Value("Orientation", out NewUnit.Orientation);
NewUnitGroup.Units.Add(NewUnit);
}
NewArmy.Units.Add(NewUnitGroup);
}
SaveArmys.Add(NewArmy);
}
#endregion
}
public string PhysicalUWP()
{
return(Size.ToString() + Atmosphere.ToString() + Hydro.ToString());
}
