public clsResult LoadDirectory(string Path)
{
clsResult ReturnResult =
new clsResult("Loading object data from " + Convert.ToString(ControlChars.Quote) + Path + Convert.ToString(ControlChars.Quote));
Path = App.EndWithPathSeperator(Path);
string SubDirNames = "";
string SubDirStructures = "";
string SubDirBrain = "";
string SubDirBody = "";
string SubDirPropulsion = "";
string SubDirBodyPropulsion = "";
string SubDirConstruction = "";
string SubDirSensor = "";
string SubDirRepair = "";
string SubDirTemplates = "";
string SubDirWeapons = "";
string SubDirECM = "";
string SubDirFeatures = "";
string SubDirStructurePIE;
string SubDirBodiesPIE;
string SubDirPropPIE;
string SubDirWeaponsPIE;
string SubDirTexpages = "";
string SubDirAssignWeapons = "";
string SubDirFeaturePIE;
string SubDirStructureWeapons = "";
string SubDirPIEs = "";
SubDirNames = "messages" + Convert.ToString(App.PlatformPathSeparator) + "strings" +
Convert.ToString(App.PlatformPathSeparator) + "names.txt";
SubDirStructures = "stats" + Convert.ToString(App.PlatformPathSeparator) + "structures.txt";
SubDirBrain = "stats" + Convert.ToString(App.PlatformPathSeparator) + "brain.txt";
SubDirBody = "stats" + Convert.ToString(App.PlatformPathSeparator) + "body.txt";
SubDirPropulsion = "stats" + Convert.ToString(App.PlatformPathSeparator) + "propulsion.txt";
SubDirBodyPropulsion = "stats" + Convert.ToString(App.PlatformPathSeparator) + "bodypropulsionimd.txt";
SubDirConstruction = "stats" + Convert.ToString(App.PlatformPathSeparator) + "construction.txt";
SubDirSensor = "stats" + Convert.ToString(App.PlatformPathSeparator) + "sensor.txt";
SubDirRepair = "stats" + Convert.ToString(App.PlatformPathSeparator) + "repair.txt";
SubDirTemplates = "stats" + Convert.ToString(App.PlatformPathSeparator) + "templates.txt";
SubDirWeapons = "stats" + Convert.ToString(App.PlatformPathSeparator) + "weapons.txt";
SubDirECM = "stats" + Convert.ToString(App.PlatformPathSeparator) + "ecm.txt";
SubDirFeatures = "stats" + Convert.ToString(App.PlatformPathSeparator) + "features.txt";
SubDirPIEs = "pies" + Convert.ToString(App.PlatformPathSeparator);
//SubDirStructurePIE = "structs" & ospathseperator
SubDirStructurePIE = SubDirPIEs;
//SubDirBodiesPIE = "components" & ospathseperator & "bodies" & ospathseperator
SubDirBodiesPIE = SubDirPIEs;
//SubDirPropPIE = "components" & ospathseperator & "prop" & ospathseperator
SubDirPropPIE = SubDirPIEs;
//SubDirWeaponsPIE = "components" & ospathseperator & "weapons" & ospathseperator
SubDirWeaponsPIE = SubDirPIEs;
SubDirTexpages = "texpages" + Convert.ToString(App.PlatformPathSeparator);
SubDirAssignWeapons = "stats" + Convert.ToString(App.PlatformPathSeparator) + "assignweapons.txt";
//SubDirFeaturePIE = "features" & ospathseperator
SubDirFeaturePIE = SubDirPIEs;
SubDirStructureWeapons = "stats" + Convert.ToString(App.PlatformPathSeparator) + "structureweapons.txt";
SimpleList<clsTextFile> CommaFiles = new SimpleList<clsTextFile>();
clsTextFile DataNames = new clsTextFile();
DataNames.SubDirectory = SubDirNames;
DataNames.UniqueField = 0;
ReturnResult.Add(DataNames.LoadNamesFile(Path));
if ( !DataNames.CalcUniqueField() )
{
ReturnResult.ProblemAdd("There are two entries for the same code in " + SubDirNames + ".");
}
clsTextFile DataStructures = new clsTextFile();
DataStructures.SubDirectory = SubDirStructures;
DataStructures.FieldCount = 25;
CommaFiles.Add(DataStructures);
clsTextFile DataBrain = new clsTextFile();
DataBrain.SubDirectory = SubDirBrain;
DataBrain.FieldCount = 9;
CommaFiles.Add(DataBrain);
clsTextFile DataBody = new clsTextFile();
DataBody.SubDirectory = SubDirBody;
DataBody.FieldCount = 25;
CommaFiles.Add(DataBody);
clsTextFile DataPropulsion = new clsTextFile();
DataPropulsion.SubDirectory = SubDirPropulsion;
DataPropulsion.FieldCount = 12;
CommaFiles.Add(DataPropulsion);
clsTextFile DataBodyPropulsion = new clsTextFile();
DataBodyPropulsion.SubDirectory = SubDirBodyPropulsion;
DataBodyPropulsion.FieldCount = 5;
DataBodyPropulsion.UniqueField = -1; //no unique requirement
CommaFiles.Add(DataBodyPropulsion);
clsTextFile DataConstruction = new clsTextFile();
DataConstruction.SubDirectory = SubDirConstruction;
DataConstruction.FieldCount = 12;
CommaFiles.Add(DataConstruction);
clsTextFile DataSensor = new clsTextFile();
DataSensor.SubDirectory = SubDirSensor;
DataSensor.FieldCount = 16;
CommaFiles.Add(DataSensor);
clsTextFile DataRepair = new clsTextFile();
DataRepair.SubDirectory = SubDirRepair;
DataRepair.FieldCount = 14;
CommaFiles.Add(DataRepair);
clsTextFile DataTemplates = new clsTextFile();
DataTemplates.SubDirectory = SubDirTemplates;
DataTemplates.FieldCount = 12;
CommaFiles.Add(DataTemplates);
clsTextFile DataECM = new clsTextFile();
DataECM.SubDirectory = SubDirECM;
DataECM.FieldCount = 14;
CommaFiles.Add(DataECM);
clsTextFile DataFeatures = new clsTextFile();
DataFeatures.SubDirectory = SubDirFeatures;
DataFeatures.FieldCount = 11;
CommaFiles.Add(DataFeatures);
clsTextFile DataAssignWeapons = new clsTextFile();
DataAssignWeapons.SubDirectory = SubDirAssignWeapons;
DataAssignWeapons.FieldCount = 5;
CommaFiles.Add(DataAssignWeapons);
clsTextFile DataWeapons = new clsTextFile();
DataWeapons.SubDirectory = SubDirWeapons;
DataWeapons.FieldCount = 53;
CommaFiles.Add(DataWeapons);
clsTextFile DataStructureWeapons = new clsTextFile();
DataStructureWeapons.SubDirectory = SubDirStructureWeapons;
DataStructureWeapons.FieldCount = 6;
CommaFiles.Add(DataStructureWeapons);
clsTextFile TextFile = default(clsTextFile);
foreach ( clsTextFile tempLoopVar_TextFile in CommaFiles )
{
TextFile = tempLoopVar_TextFile;
clsResult Result = TextFile.LoadCommaFile(Path);
ReturnResult.Add(Result);
if ( !Result.HasProblems )
{
if ( TextFile.CalcIsFieldCountValid() )
{
if ( !TextFile.CalcUniqueField() )
{
ReturnResult.ProblemAdd("An entry in field " + Convert.ToString(TextFile.UniqueField) + " was not unique for file " +
TextFile.SubDirectory + ".");
}
}
else
{
ReturnResult.ProblemAdd("There were entries with the wrong number of fields for file " + TextFile.SubDirectory + ".");
}
}
}
if ( ReturnResult.HasProblems )
{
return ReturnResult;
}
//load texpages
string[] TexFiles = null;
try
{
TexFiles = Directory.GetFiles(Path + SubDirTexpages);
}
catch ( Exception )
{
ReturnResult.WarningAdd("Unable to access texture pages.");
TexFiles = new string[0];
}
string Text = "";
Bitmap Bitmap = null;
int InstrPos2 = 0;
BitmapGLTexture BitmapTextureArgs = new BitmapGLTexture();
App.sResult BitmapResult = new App.sResult();
foreach ( string tempLoopVar_Text in TexFiles )
{
Text = tempLoopVar_Text;
if ( Text.Substring(Text.Length - 4, 4).ToLower() == ".png" )
{
clsResult Result =
new clsResult("Loading texture page " + Convert.ToString(ControlChars.Quote) + Text + Convert.ToString(ControlChars.Quote));
if ( File.Exists(Text) )
{
BitmapResult = BitmapUtil.LoadBitmap(Text, ref Bitmap);
clsTexturePage NewPage = new clsTexturePage();
if ( BitmapResult.Success )
{
Result.Take(BitmapUtil.BitmapIsGLCompatible(Bitmap));
BitmapTextureArgs.MagFilter = TextureMagFilter.Nearest;
BitmapTextureArgs.MinFilter = TextureMinFilter.Nearest;
BitmapTextureArgs.TextureNum = 0;
BitmapTextureArgs.MipMapLevel = 0;
BitmapTextureArgs.Texture = Bitmap;
BitmapTextureArgs.Perform();
NewPage.GLTexture_Num = BitmapTextureArgs.TextureNum;
}
else
{
Result.WarningAdd(BitmapResult.Problem);
}
InstrPos2 = Strings.InStrRev(Text, App.PlatformPathSeparator.ToString(), -1, (CompareMethod)0);
NewPage.FileTitle = Strings.Mid(Text, InstrPos2 + 1, Text.Length - 4 - InstrPos2);
TexturePages.Add(NewPage);
}
else
{
Result.WarningAdd("Texture page missing (" + Text + ").");
}
ReturnResult.Add(Result);
}
}
//load PIEs
string[] PIE_Files = null;
SimpleList<clsPIE> PIE_List = new SimpleList<clsPIE>();
clsPIE NewPIE = default(clsPIE);
try
{
PIE_Files = Directory.GetFiles(Path + SubDirPIEs);
}
catch ( Exception )
{
ReturnResult.WarningAdd("Unable to access PIE files.");
PIE_Files = new string[0];
}
App.sSplitPath SplitPath = new App.sSplitPath();
foreach ( string tempLoopVar_Text in PIE_Files )
{
Text = tempLoopVar_Text;
SplitPath = new App.sSplitPath(Text);
if ( SplitPath.FileExtension.ToLower() == "pie" )
{
NewPIE = new clsPIE();
NewPIE.Path = Text;
NewPIE.LCaseFileTitle = SplitPath.FileTitle.ToLower();
PIE_List.Add(NewPIE);
}
}
//interpret stats
clsUnitType.clsAttachment Attachment = default(clsUnitType.clsAttachment);
clsUnitType.clsAttachment BaseAttachment = default(clsUnitType.clsAttachment);
sXYZ_sng Connector = new sXYZ_sng();
clsStructureType StructureType = default(clsStructureType);
clsFeatureType FeatureType = default(clsFeatureType);
clsDroidTemplate Template = default(clsDroidTemplate);
clsBody Body = default(clsBody);
clsPropulsion Propulsion = default(clsPropulsion);
clsConstruct Construct = default(clsConstruct);
clsWeapon Weapon = default(clsWeapon);
clsRepair Repair = default(clsRepair);
clsSensor Sensor = default(clsSensor);
clsBrain Brain = default(clsBrain);
clsECM ECM = default(clsECM);
string[] Fields = null;
//interpret body
foreach ( string[] tempLoopVar_Fields in DataBody.ResultData )
{
Fields = tempLoopVar_Fields;
Body = new clsBody();
Body.ObjectDataLink.Connect(Bodies);
Body.Code = Fields[0];
SetComponentName(DataNames.ResultData, Body, ReturnResult);
IOUtil.InvariantParse(Fields[6], ref Body.Hitpoints);
Body.Designable = Fields[24] != "0";
Body.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[7].ToLower(), ReturnResult));
}
//interpret propulsion
foreach ( string[] tempLoopVar_Fields in DataPropulsion.ResultData )
{
Fields = tempLoopVar_Fields;
Propulsion = new clsPropulsion(Bodies.Count);
Propulsion.ObjectDataLink.Connect(Propulsions);
Propulsion.Code = Fields[0];
SetComponentName(DataNames.ResultData, Propulsion, ReturnResult);
IOUtil.InvariantParse(Fields[7], ref Propulsion.HitPoints);
//.Propulsions(Propulsion_Num).PIE = LCase(DataPropulsion.Entries(Propulsion_Num).FieldValues(8))
Propulsion.Designable = Fields[11] != "0";
}
//interpret body-propulsions
BodyProp[,] BodyPropulsionPIEs = new BodyProp[Bodies.Count, Propulsions.Count];
for ( int A = 0; A <= Bodies.Count - 1; A++ )
{
for ( int B = 0; B <= Propulsions.Count - 1; B++ )
{
BodyPropulsionPIEs[A, B] = new BodyProp();
BodyPropulsionPIEs[A, B].LeftPIE = "0";
BodyPropulsionPIEs[A, B].RightPIE = "0";
}
}
foreach ( string[] tempLoopVar_Fields in DataBodyPropulsion.ResultData )
{
Fields = tempLoopVar_Fields;
Body = FindBodyCode(Fields[0]);
Propulsion = FindPropulsionCode(Fields[1]);
if ( Body != null && Propulsion != null )
{
if ( Fields[2] != "0" )
{
BodyPropulsionPIEs[Body.ObjectDataLink.ArrayPosition, Propulsion.ObjectDataLink.ArrayPosition].LeftPIE = Fields[2].ToLower();
}
if ( Fields[3] != "0" )
{
BodyPropulsionPIEs[Body.ObjectDataLink.ArrayPosition, Propulsion.ObjectDataLink.ArrayPosition].RightPIE = Fields[3].ToLower();
}
}
}
//set propulsion-body PIEs
for ( int A = 0; A <= Propulsions.Count - 1; A++ )
{
Propulsion = Propulsions[A];
for ( int B = 0; B <= Bodies.Count - 1; B++ )
{
Body = Bodies[B];
Propulsion.Bodies[B].LeftAttachment = new clsUnitType.clsAttachment();
Propulsion.Bodies[B].LeftAttachment.Models.Add(GetModelForPIE(PIE_List, BodyPropulsionPIEs[B, A].LeftPIE, ReturnResult));
Propulsion.Bodies[B].RightAttachment = new clsUnitType.clsAttachment();
Propulsion.Bodies[B].RightAttachment.Models.Add(GetModelForPIE(PIE_List, BodyPropulsionPIEs[B, A].RightPIE, ReturnResult));
}
}
//interpret construction
foreach ( string[] tempLoopVar_Fields in DataConstruction.ResultData )
{
Fields = tempLoopVar_Fields;
Construct = new clsConstruct();
Construct.ObjectDataLink.Connect(Constructors);
Construct.TurretObjectDataLink.Connect(Turrets);
Construct.Code = Fields[0];
SetComponentName(DataNames.ResultData, Construct, ReturnResult);
Construct.Designable = Fields[11] != "0";
Construct.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[8].ToLower(), ReturnResult));
}
//interpret weapons
foreach ( string[] tempLoopVar_Fields in DataWeapons.ResultData )
{
Fields = tempLoopVar_Fields;
Weapon = new clsWeapon();
Weapon.ObjectDataLink.Connect(Weapons);
Weapon.TurretObjectDataLink.Connect(Turrets);
Weapon.Code = Fields[0];
SetComponentName(DataNames.ResultData, Weapon, ReturnResult);
IOUtil.InvariantParse(Fields[7], ref Weapon.HitPoints);
Weapon.Designable = Fields[51] != "0";
Weapon.Attachment.Models.Add(GetModelForPIE(PIE_List, Convert.ToString(Fields[8].ToLower()), ReturnResult));
Weapon.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[9].ToLower(), ReturnResult));
}
//interpret sensor
foreach ( string[] tempLoopVar_Fields in DataSensor.ResultData )
{
Fields = tempLoopVar_Fields;
Sensor = new clsSensor();
Sensor.ObjectDataLink.Connect(Sensors);
Sensor.TurretObjectDataLink.Connect(Turrets);
Sensor.Code = Fields[0];
SetComponentName(DataNames.ResultData, Sensor, ReturnResult);
IOUtil.InvariantParse(Fields[7], ref Sensor.HitPoints);
Sensor.Designable = Fields[15] != "0";
switch ( Fields[11].ToLower() )
{
case "turret":
Sensor.Location = clsSensor.enumLocation.Turret;
break;
case "default":
Sensor.Location = clsSensor.enumLocation.Invisible;
break;
default:
Sensor.Location = clsSensor.enumLocation.Invisible;
break;
}
Sensor.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[8].ToLower(), ReturnResult));
Sensor.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[9].ToLower(), ReturnResult));
}
//interpret repair
foreach ( string[] tempLoopVar_Fields in DataRepair.ResultData )
{
Fields = tempLoopVar_Fields;
Repair = new clsRepair();
Repair.ObjectDataLink.Connect(Repairs);
Repair.TurretObjectDataLink.Connect(Turrets);
Repair.Code = Fields[0];
SetComponentName(DataNames.ResultData, Repair, ReturnResult);
Repair.Designable = Fields[13] != "0";
Repair.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[9].ToLower(), ReturnResult));
Repair.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[10].ToLower(), ReturnResult));
}
//interpret brain
foreach ( string[] tempLoopVar_Fields in DataBrain.ResultData )
{
Fields = tempLoopVar_Fields;
Brain = new clsBrain();
Brain.ObjectDataLink.Connect(Brains);
Brain.TurretObjectDataLink.Connect(Turrets);
Brain.Code = Fields[0];
SetComponentName(DataNames.ResultData, Brain, ReturnResult);
Brain.Designable = true;
Weapon = FindWeaponCode(Fields[7]);
if ( Weapon != null )
{
Brain.Weapon = Weapon;
Brain.Attachment = Weapon.Attachment;
}
}
//interpret ecm
foreach ( string[] tempLoopVar_Fields in DataECM.ResultData )
{
Fields = tempLoopVar_Fields;
ECM = new clsECM();
ECM.ObjectDataLink.Connect(ECMs);
ECM.TurretObjectDataLink.Connect(Turrets);
ECM.Code = Fields[0];
SetComponentName(DataNames.ResultData, ECM, ReturnResult);
IOUtil.InvariantParse(Fields[7], ref ECM.HitPoints);
ECM.Designable = false;
ECM.Attachment.Models.Add(GetModelForPIE(PIE_List, Fields[8].ToLower(), ReturnResult));
}
//interpret feature
foreach ( string[] tempLoopVar_Fields in DataFeatures.ResultData )
{
Fields = tempLoopVar_Fields;
FeatureType = new clsFeatureType();
FeatureType.UnitType_ObjectDataLink.Connect(UnitTypes);
FeatureType.FeatureType_ObjectDataLink.Connect(FeatureTypes);
FeatureType.Code = Fields[0];
if ( Fields[7] == "OIL RESOURCE" ) //type
{
FeatureType.FeatureType = clsFeatureType.enumFeatureType.OilResource;
}
SetFeatureName(DataNames.ResultData, FeatureType, ReturnResult);
if ( !IOUtil.InvariantParse(Fields[1], ref FeatureType.Footprint.X) )
{
ReturnResult.WarningAdd("Feature footprint-x was not an integer for " + FeatureType.Code + ".");
}
if ( !IOUtil.InvariantParse(Fields[2], ref FeatureType.Footprint.Y) )
{
ReturnResult.WarningAdd("Feature footprint-y was not an integer for " + FeatureType.Code + ".");
}
FeatureType.BaseAttachment = new clsUnitType.clsAttachment();
BaseAttachment = FeatureType.BaseAttachment;
Text = Fields[6].ToLower();
Attachment = BaseAttachment.CreateAttachment();
Attachment.Models.Add(GetModelForPIE(PIE_List, Text, ReturnResult));
}
//interpret structure
foreach ( string[] tempLoopVar_Fields in DataStructures.ResultData )
{
Fields = tempLoopVar_Fields;
string StructureCode = Fields[0];
string StructureTypeText = Fields[1];
string[] StructurePIEs = Fields[21].ToLower().Split('@');
sXY_int StructureFootprint = new sXY_int();
string StructureBasePIE = Fields[22].ToLower();
if ( !IOUtil.InvariantParse(Fields[5], ref StructureFootprint.X) )
{
ReturnResult.WarningAdd("Structure footprint-x was not an integer for " + StructureCode + ".");
}
if ( !IOUtil.InvariantParse(Fields[6], ref StructureFootprint.Y) )
{
ReturnResult.WarningAdd("Structure footprint-y was not an integer for " + StructureCode + ".");
}
if ( StructureTypeText != "WALL" || StructurePIEs.GetLength(0) != 4 )
{
//this is NOT a generic wall
StructureType = new clsStructureType();
StructureType.UnitType_ObjectDataLink.Connect(UnitTypes);
StructureType.StructureType_ObjectDataLink.Connect(StructureTypes);
StructureType.Code = StructureCode;
SetStructureName(DataNames.ResultData, StructureType, ReturnResult);
StructureType.Footprint = StructureFootprint;
switch ( StructureTypeText )
{
case "DEMOLISH":
StructureType.StructureType = clsStructureType.enumStructureType.Demolish;
break;
case "WALL":
StructureType.StructureType = clsStructureType.enumStructureType.Wall;
break;
case "CORNER WALL":
StructureType.StructureType = clsStructureType.enumStructureType.CornerWall;
break;
case "FACTORY":
StructureType.StructureType = clsStructureType.enumStructureType.Factory;
break;
case "CYBORG FACTORY":
StructureType.StructureType = clsStructureType.enumStructureType.CyborgFactory;
break;
case "VTOL FACTORY":
StructureType.StructureType = clsStructureType.enumStructureType.VTOLFactory;
break;
case "COMMAND":
StructureType.StructureType = clsStructureType.enumStructureType.Command;
break;
case "HQ":
StructureType.StructureType = clsStructureType.enumStructureType.HQ;
break;
case "DEFENSE":
StructureType.StructureType = clsStructureType.enumStructureType.Defense;
break;
case "POWER GENERATOR":
StructureType.StructureType = clsStructureType.enumStructureType.PowerGenerator;
break;
case "POWER MODULE":
StructureType.StructureType = clsStructureType.enumStructureType.PowerModule;
break;
case "RESEARCH":
StructureType.StructureType = clsStructureType.enumStructureType.Research;
break;
case "RESEARCH MODULE":
StructureType.StructureType = clsStructureType.enumStructureType.ResearchModule;
break;
case "FACTORY MODULE":
StructureType.StructureType = clsStructureType.enumStructureType.FactoryModule;
break;
case "DOOR":
StructureType.StructureType = clsStructureType.enumStructureType.DOOR;
break;
case "REPAIR FACILITY":
StructureType.StructureType = clsStructureType.enumStructureType.RepairFacility;
break;
case "SAT UPLINK":
StructureType.StructureType = clsStructureType.enumStructureType.DOOR;
break;
case "REARM PAD":
StructureType.StructureType = clsStructureType.enumStructureType.RearmPad;
break;
case "MISSILE SILO":
StructureType.StructureType = clsStructureType.enumStructureType.MissileSilo;
break;
case "RESOURCE EXTRACTOR":
StructureType.StructureType = clsStructureType.enumStructureType.ResourceExtractor;
break;
default:
StructureType.StructureType = clsStructureType.enumStructureType.Unknown;
break;
}
BaseAttachment = StructureType.BaseAttachment;
if ( StructurePIEs.GetLength(0) > 0 )
{
BaseAttachment.Models.Add(GetModelForPIE(PIE_List, StructurePIEs[0], ReturnResult));
}
StructureType.StructureBasePlate = GetModelForPIE(PIE_List, StructureBasePIE, ReturnResult);
if ( BaseAttachment.Models.Count == 1 )
{
if ( BaseAttachment.Models[0].ConnectorCount >= 1 )
{
Connector = BaseAttachment.Models[0].Connectors[0];
SimpleList<string[]> StructureWeapons = default(SimpleList<string[]>);
StructureWeapons = GetRowsWithValue(DataStructureWeapons.ResultData, StructureType.Code);
if ( StructureWeapons.Count > 0 )
{
Weapon = FindWeaponCode(Convert.ToString(StructureWeapons[0][1]));
}
else
{
Weapon = null;
}
ECM = FindECMCode(Fields[18]);
Sensor = FindSensorCode(Fields[19]);
if ( Weapon != null )
{
if ( Weapon.Code != "ZNULLWEAPON" )
{
Attachment = BaseAttachment.CopyAttachment(Weapon.Attachment);
Attachment.Pos_Offset = Connector;
}
}
if ( ECM != null )
{
if ( ECM.Code != "ZNULLECM" )
{
Attachment = BaseAttachment.CopyAttachment(ECM.Attachment);
Attachment.Pos_Offset = Connector;
}
}
if ( Sensor != null )
{
if ( Sensor.Code != "ZNULLSENSOR" )
{
Attachment = BaseAttachment.CopyAttachment(Sensor.Attachment);
Attachment.Pos_Offset = Connector;
}
}
}
}
}
else
{
//this is a generic wall
clsWallType NewWall = new clsWallType();
NewWall.WallType_ObjectDataLink.Connect(WallTypes);
NewWall.Code = StructureCode;
SetWallName(DataNames.ResultData, NewWall, ReturnResult);
clsModel WallBasePlate = GetModelForPIE(PIE_List, StructureBasePIE, ReturnResult);
int WallNum = 0;
clsStructureType WallStructureType = default(clsStructureType);
for ( WallNum = 0; WallNum <= 3; WallNum++ )
{
WallStructureType = new clsStructureType();
WallStructureType.UnitType_ObjectDataLink.Connect(UnitTypes);
WallStructureType.StructureType_ObjectDataLink.Connect(StructureTypes);
WallStructureType.WallLink.Connect(NewWall.Segments);
WallStructureType.Code = StructureCode;
Text = NewWall.Name;
switch ( WallNum )
{
case 0:
Text += " - ";
break;
case 1:
Text += " + ";
break;
case 2:
Text += " T ";
break;
case 3:
Text += " L ";
break;
}
WallStructureType.Name = Text;
WallStructureType.Footprint = StructureFootprint;
WallStructureType.StructureType = clsStructureType.enumStructureType.Wall;
BaseAttachment = WallStructureType.BaseAttachment;
Text = StructurePIEs[WallNum];
BaseAttachment.Models.Add(GetModelForPIE(PIE_List, Text, ReturnResult));
WallStructureType.StructureBasePlate = WallBasePlate;
}
}
}
//interpret templates
int TurretConflictCount = 0;
foreach ( string[] tempLoopVar_Fields in DataTemplates.ResultData )
{
Fields = tempLoopVar_Fields;
Template = new clsDroidTemplate();
Template.UnitType_ObjectDataLink.Connect(UnitTypes);
Template.DroidTemplate_ObjectDataLink.Connect(DroidTemplates);
Template.Code = Fields[0];
SetTemplateName(DataNames.ResultData, Template, ReturnResult);
switch ( Fields[9] ) //type
{
case "ZNULLDROID":
Template.TemplateDroidType = App.TemplateDroidType_Null;
break;
case "DROID":
Template.TemplateDroidType = App.TemplateDroidType_Droid;
break;
case "CYBORG":
Template.TemplateDroidType = App.TemplateDroidType_Cyborg;
break;
case "CYBORG_CONSTRUCT":
Template.TemplateDroidType = App.TemplateDroidType_CyborgConstruct;
break;
case "CYBORG_REPAIR":
Template.TemplateDroidType = App.TemplateDroidType_CyborgRepair;
break;
case "CYBORG_SUPER":
Template.TemplateDroidType = App.TemplateDroidType_CyborgSuper;
break;
case "TRANSPORTER":
Template.TemplateDroidType = App.TemplateDroidType_Transporter;
break;
case "PERSON":
Template.TemplateDroidType = App.TemplateDroidType_Person;
break;
default:
Template.TemplateDroidType = null;
ReturnResult.WarningAdd("Template " + Template.GetDisplayTextCode() + " had an unrecognised type.");
break;
}
clsDroidDesign.sLoadPartsArgs LoadPartsArgs = new clsDroidDesign.sLoadPartsArgs();
LoadPartsArgs.Body = FindBodyCode(Fields[2]);
LoadPartsArgs.Brain = FindBrainCode(Fields[3]);
LoadPartsArgs.Construct = FindConstructorCode(Fields[4]);
LoadPartsArgs.ECM = FindECMCode(Fields[5]);
LoadPartsArgs.Propulsion = FindPropulsionCode(Fields[7]);
LoadPartsArgs.Repair = FindRepairCode(Fields[8]);
LoadPartsArgs.Sensor = FindSensorCode(Fields[10]);
SimpleList<string[]> TemplateWeapons = GetRowsWithValue(DataAssignWeapons.ResultData, Template.Code);
if ( TemplateWeapons.Count > 0 )
{
Text = Convert.ToString(TemplateWeapons[0][1]);
if ( Text != "NULL" )
{
LoadPartsArgs.Weapon1 = FindWeaponCode(Text);
}
Text = Convert.ToString(TemplateWeapons[0][2]);
if ( Text != "NULL" )
{
LoadPartsArgs.Weapon2 = FindWeaponCode(Text);
}
Text = Convert.ToString(TemplateWeapons[0][3]);
if ( Text != "NULL" )
{
LoadPartsArgs.Weapon3 = FindWeaponCode(Text);
}
}
if ( !Template.LoadParts(LoadPartsArgs) )
{
if ( TurretConflictCount < 16 )
{
ReturnResult.WarningAdd("Template " + Template.GetDisplayTextCode() + " had multiple conflicting turrets.");
}
TurretConflictCount++;
}
}
if ( TurretConflictCount > 0 )
{
ReturnResult.WarningAdd(TurretConflictCount + " templates had multiple conflicting turrets.");
}
return ReturnResult;
}
public void SetFeatureName(SimpleList<string[]> Names, clsFeatureType FeatureType, clsResult Result)
{
SimpleList<string[]> ValueSearchResults = default(SimpleList<string[]>);
ValueSearchResults = GetRowsWithValue(Names, FeatureType.Code);
if ( ValueSearchResults.Count == 0 )
{
Result.WarningAdd("No name for feature type " + FeatureType.Code + ".");
}
else
{
FeatureType.Name = Convert.ToString(ValueSearchResults[0][1]);
}
}
public clsUnitType FindOrCreateUnitType(string Code, clsUnitType.enumType Type, int WallType)
{
switch ( Type )
{
case clsUnitType.enumType.Feature:
clsFeatureType FeatureType = default(clsFeatureType);
foreach ( clsFeatureType tempLoopVar_FeatureType in FeatureTypes )
{
FeatureType = tempLoopVar_FeatureType;
if ( FeatureType.Code == Code )
{
return FeatureType;
}
}
FeatureType = new clsFeatureType();
FeatureType.IsUnknown = true;
FeatureType.Code = Code;
FeatureType.Footprint.X = 1;
FeatureType.Footprint.Y = 1;
return FeatureType;
case clsUnitType.enumType.PlayerStructure:
clsStructureType StructureType = default(clsStructureType);
foreach ( clsStructureType tempLoopVar_StructureType in StructureTypes )
{
StructureType = tempLoopVar_StructureType;
if ( StructureType.Code == Code )
{
if ( WallType < 0 )
{
return StructureType;
}
else if ( StructureType.WallLink.IsConnected )
{
if ( StructureType.WallLink.ArrayPosition == WallType )
{
return StructureType;
}
}
}
}
StructureType = new clsStructureType();
StructureType.IsUnknown = true;
StructureType.Code = Code;
StructureType.Footprint.X = 1;
StructureType.Footprint.Y = 1;
return StructureType;
case clsUnitType.enumType.PlayerDroid:
clsDroidTemplate DroidType = default(clsDroidTemplate);
foreach ( clsDroidTemplate tempLoopVar_DroidType in DroidTemplates )
{
DroidType = tempLoopVar_DroidType;
if ( DroidType.IsTemplate )
{
if ( DroidType.Code == Code )
{
return DroidType;
}
}
}
DroidType = new clsDroidTemplate();
DroidType.IsUnknown = true;
DroidType.Code = Code;
return DroidType;
default:
return null;
}
}
private clsResult ValidateMap_UnitPositions()
{
clsResult Result = new clsResult("Validate unit positions");
//check unit positions
bool[,] TileHasUnit = new bool[Map.Terrain.TileSize.X, Map.Terrain.TileSize.Y];
clsStructureType[,] TileStructureType = new clsStructureType[Map.Terrain.TileSize.X, Map.Terrain.TileSize.Y];
clsFeatureType[,] TileFeatureType = new clsFeatureType[Map.Terrain.TileSize.X, Map.Terrain.TileSize.Y];
clsMap.clsUnitGroup[,] TileObjectGroup = new clsMap.clsUnitGroup[Map.Terrain.TileSize.X, Map.Terrain.TileSize.Y];
int X = 0;
int Y = 0;
sXY_int StartPos = new sXY_int();
sXY_int FinishPos = new sXY_int();
sXY_int CentrePos = new sXY_int();
clsStructureType.enumStructureType StructureTypeType;
clsStructureType StructureType = default(clsStructureType);
sXY_int Footprint = new sXY_int();
bool[] UnitIsStructureModule = new bool[Map.Units.Count];
bool IsValid = default(bool);
clsMap.clsUnit Unit = default(clsMap.clsUnit);
foreach ( clsMap.clsUnit tempLoopVar_Unit in Map.Units )
{
Unit = tempLoopVar_Unit;
if ( Unit.Type.Type == clsUnitType.enumType.PlayerStructure )
{
StructureType = (clsStructureType)Unit.Type;
StructureTypeType = StructureType.StructureType;
UnitIsStructureModule[Unit.MapLink.ArrayPosition] = StructureType.IsModule() |
StructureTypeType == clsStructureType.enumStructureType.ResourceExtractor;
}
}
//check and store non-module units first. modules need to check for the underlying unit.
foreach ( clsMap.clsUnit tempLoopVar_Unit in Map.Units )
{
Unit = tempLoopVar_Unit;
if ( !UnitIsStructureModule[Unit.MapLink.ArrayPosition] )
{
Footprint = Unit.Type.get_GetFootprintSelected(Unit.Rotation);
Map.GetFootprintTileRange(Unit.Pos.Horizontal, Footprint, StartPos, FinishPos);
if ( StartPos.X < 0 | FinishPos.X >= Map.Terrain.TileSize.X
| StartPos.Y < 0 | FinishPos.Y >= Map.Terrain.TileSize.Y )
{
clsResultProblemGoto<clsResultItemPosGoto> resultItem = modResults.CreateResultProblemGotoForObject(Unit);
resultItem.Text = "Unit off map at position " + Unit.GetPosText() + ".";
Result.ItemAdd(resultItem);
}
else
{
for ( Y = StartPos.Y; Y <= FinishPos.Y; Y++ )
{
for ( X = StartPos.X; X <= FinishPos.X; X++ )
{
if ( TileHasUnit[X, Y] )
{
clsResultProblemGoto<clsResultItemPosGoto> resultItem = modResults.CreateResultProblemGotoForObject(Unit);
resultItem.Text = "Bad unit overlap on tile " + Convert.ToString(X) + ", " + Convert.ToString(Y) + ".";
Result.ItemAdd(resultItem);
}
else
{
TileHasUnit[X, Y] = true;
if ( Unit.Type.Type == clsUnitType.enumType.PlayerStructure )
{
TileStructureType[X, Y] = (clsStructureType)Unit.Type;
}
else if ( Unit.Type.Type == clsUnitType.enumType.Feature )
{
TileFeatureType[X, Y] = (clsFeatureType)Unit.Type;
}
TileObjectGroup[X, Y] = Unit.UnitGroup;
}
}
}
}
}
}
//check modules and extractors
foreach ( clsMap.clsUnit tempLoopVar_Unit in Map.Units )
{
Unit = tempLoopVar_Unit;
if ( UnitIsStructureModule[Unit.MapLink.ArrayPosition] )
{
StructureTypeType = ((clsStructureType)Unit.Type).StructureType;
CentrePos.X = Conversion.Int(Unit.Pos.Horizontal.X / App.TerrainGridSpacing);
CentrePos.Y = (int)(Conversion.Int(Unit.Pos.Horizontal.Y / App.TerrainGridSpacing));
if ( CentrePos.X < 0 | CentrePos.X >= Map.Terrain.TileSize.X
| CentrePos.Y < 0 | CentrePos.Y >= Map.Terrain.TileSize.Y )
{
clsResultProblemGoto<clsResultItemPosGoto> resultItem = modResults.CreateResultProblemGotoForObject(Unit);
resultItem.Text = "Module off map at position " + Unit.GetPosText() + ".";
Result.ItemAdd(resultItem);
}
else
{
if ( TileStructureType[CentrePos.X, CentrePos.Y] != null )
{
if ( TileObjectGroup[CentrePos.X, CentrePos.Y] == Unit.UnitGroup )
{
if ( StructureTypeType == clsStructureType.enumStructureType.FactoryModule )
{
if ( TileStructureType[CentrePos.X, CentrePos.Y].StructureType == clsStructureType.enumStructureType.Factory
| TileStructureType[CentrePos.X, CentrePos.Y].StructureType == clsStructureType.enumStructureType.VTOLFactory )
{
IsValid = true;
}
else
{
IsValid = false;
}
}
else if ( StructureTypeType == clsStructureType.enumStructureType.PowerModule )
{
if ( TileStructureType[CentrePos.X, CentrePos.Y].StructureType == clsStructureType.enumStructureType.PowerGenerator )
{
IsValid = true;
}
else
{
IsValid = false;
}
}
else if ( StructureTypeType == clsStructureType.enumStructureType.ResearchModule )
{
if ( TileStructureType[CentrePos.X, CentrePos.Y].StructureType == clsStructureType.enumStructureType.Research )
{
IsValid = true;
}
else
{
IsValid = false;
}
}
else
{
IsValid = false;
}
}
else
{
IsValid = false;
}
}
else if ( TileFeatureType[CentrePos.X, CentrePos.Y] != null )
{
if ( StructureTypeType == clsStructureType.enumStructureType.ResourceExtractor )
{
if ( TileFeatureType[CentrePos.X, CentrePos.Y].FeatureType == clsFeatureType.enumFeatureType.OilResource )
{
IsValid = true;
}
else
{
IsValid = false;
}
}
else
{
IsValid = false;
}
}
else if ( StructureTypeType == clsStructureType.enumStructureType.ResourceExtractor )
{
IsValid = true;
}
else
{
IsValid = false;
}
if ( !IsValid )
{
clsResultProblemGoto<clsResultItemPosGoto> resultItem = modResults.CreateResultProblemGotoForObject(Unit);
resultItem.Text = "Bad module on tile " + Convert.ToString(CentrePos.X) + ", " + Convert.ToString(CentrePos.Y) + ".";
Result.ItemAdd(resultItem);
}
}
}
}
return Result;
}