Example #1
0
        private clsResult ValidateMap_UnitPositions()
        {
            clsStructureType.enumStructureType structureType;
            clsMap.clsUnit current;
            IEnumerator enumerator;
            IEnumerator enumerator2;
            IEnumerator enumerator3;
            clsResult result = new clsResult("Validate unit positions");
            bool[,] flagArray = new bool[(this.Map.Terrain.TileSize.X - 1) + 1, (this.Map.Terrain.TileSize.Y - 1) + 1];
            clsStructureType[,] typeArray2 = new clsStructureType[(this.Map.Terrain.TileSize.X - 1) + 1, (this.Map.Terrain.TileSize.Y - 1) + 1];
            clsFeatureType[,] typeArray = new clsFeatureType[(this.Map.Terrain.TileSize.X - 1) + 1, (this.Map.Terrain.TileSize.Y - 1) + 1];
            clsMap.clsUnitGroup[,] groupArray = new clsMap.clsUnitGroup[(this.Map.Terrain.TileSize.X - 1) + 1, (this.Map.Terrain.TileSize.Y - 1) + 1];
            bool[] flagArray2 = new bool[(this.Map.Units.Count - 1) + 1];
            try
            {
                enumerator = this.Map.Units.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    current = (clsMap.clsUnit) enumerator.Current;
                    if (current.Type.Type == clsUnitType.enumType.PlayerStructure)
                    {
                        clsStructureType type = (clsStructureType) current.Type;
                        structureType = type.StructureType;
                        flagArray2[current.MapLink.ArrayPosition] = type.IsModule() | (structureType == clsStructureType.enumStructureType.ResourceExtractor);
                    }
                }
            }
            finally
            {
                if (enumerator is IDisposable)
                {
                    (enumerator as IDisposable).Dispose();
                }
            }
            try
            {
                enumerator2 = this.Map.Units.GetEnumerator();
                while (enumerator2.MoveNext())
                {
                    current = (clsMap.clsUnit) enumerator2.Current;
                    if (!flagArray2[current.MapLink.ArrayPosition])
                    {
                        modMath.sXY_int _int2;
                        modMath.sXY_int _int4;
                        modMath.sXY_int footprint = current.Type.get_GetFootprintSelected(current.Rotation);
                        this.Map.GetFootprintTileRange(current.Pos.Horizontal, footprint, ref _int4, ref _int2);
                        if ((((_int4.X < 0) | (_int2.X >= this.Map.Terrain.TileSize.X)) | (_int4.Y < 0)) | (_int2.Y >= this.Map.Terrain.TileSize.Y))
                        {
                            clsResultProblemGoto<clsResultItemPosGoto> item = modResults.CreateResultProblemGotoForObject(current);
                            item.Text = "Unit off map at position " + current.GetPosText() + ".";
                            result.ItemAdd(item);
                        }
                        else
                        {
                            int y = _int2.Y;
                            for (int i = _int4.Y; i <= y; i++)
                            {
                                int x = _int2.X;
                                for (int j = _int4.X; j <= x; j++)
                                {
                                    if (flagArray[j, i])
                                    {
                                        clsResultProblemGoto<clsResultItemPosGoto> goto2 = modResults.CreateResultProblemGotoForObject(current);
                                        goto2.Text = "Bad unit overlap on tile " + Conversions.ToString(j) + ", " + Conversions.ToString(i) + ".";
                                        result.ItemAdd(goto2);
                                    }
                                    else
                                    {
                                        flagArray[j, i] = true;
                                        if (current.Type.Type == clsUnitType.enumType.PlayerStructure)
                                        {
                                            typeArray2[j, i] = (clsStructureType) current.Type;
                                        }
                                        else if (current.Type.Type == clsUnitType.enumType.Feature)
                                        {
                                            typeArray[j, i] = (clsFeatureType) current.Type;
                                        }
                                        groupArray[j, i] = current.UnitGroup;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                if (enumerator2 is IDisposable)
                {
                    (enumerator2 as IDisposable).Dispose();
                }
            }
            try
            {
                enumerator3 = this.Map.Units.GetEnumerator();
                while (enumerator3.MoveNext())
                {
                    modMath.sXY_int _int;
                    bool flag;
                    current = (clsMap.clsUnit) enumerator3.Current;
                    if (!flagArray2[current.MapLink.ArrayPosition])
                    {
                        continue;
                    }
                    structureType = ((clsStructureType) current.Type).StructureType;
                    _int.X = (int) Math.Round(((double) (((double) current.Pos.Horizontal.X) / 128.0)));
                    _int.Y = (int) Math.Round(((double) (((double) current.Pos.Horizontal.Y) / 128.0)));
                    if ((((_int.X < 0) | (_int.X >= this.Map.Terrain.TileSize.X)) | (_int.Y < 0)) | (_int.Y >= this.Map.Terrain.TileSize.Y))
                    {
                        clsResultProblemGoto<clsResultItemPosGoto> goto3 = modResults.CreateResultProblemGotoForObject(current);
                        goto3.Text = "Module off map at position " + current.GetPosText() + ".";
                        result.ItemAdd(goto3);
                        continue;
                    }
                    if (typeArray2[_int.X, _int.Y] != null)
                    {
                        if (groupArray[_int.X, _int.Y] == current.UnitGroup)
                        {
                            switch (structureType)
                            {
                                case clsStructureType.enumStructureType.FactoryModule:
                                    if ((typeArray2[_int.X, _int.Y].StructureType == clsStructureType.enumStructureType.Factory) | (typeArray2[_int.X, _int.Y].StructureType == clsStructureType.enumStructureType.VTOLFactory))
                                    {
                                        flag = true;
                                    }
                                    else
                                    {
                                        flag = false;
                                    }
                                    goto Label_0648;

                                case clsStructureType.enumStructureType.PowerModule:
                                    if (typeArray2[_int.X, _int.Y].StructureType == clsStructureType.enumStructureType.PowerGenerator)
                                    {
                                        flag = true;
                                    }
                                    else
                                    {
                                        flag = false;
                                    }
                                    goto Label_0648;

                                case clsStructureType.enumStructureType.ResearchModule:
                                    if (typeArray2[_int.X, _int.Y].StructureType == clsStructureType.enumStructureType.Research)
                                    {
                                        flag = true;
                                    }
                                    else
                                    {
                                        flag = false;
                                    }
                                    goto Label_0648;
                            }
                            flag = false;
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    else if (typeArray[_int.X, _int.Y] != null)
                    {
                        if (structureType == clsStructureType.enumStructureType.ResourceExtractor)
                        {
                            if (typeArray[_int.X, _int.Y].FeatureType == clsFeatureType.enumFeatureType.OilResource)
                            {
                                flag = true;
                            }
                            else
                            {
                                flag = false;
                            }
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    else if (structureType == clsStructureType.enumStructureType.ResourceExtractor)
                    {
                        flag = true;
                    }
                    else
                    {
                        flag = false;
                    }
                Label_0648:
                    if (!flag)
                    {
                        clsResultProblemGoto<clsResultItemPosGoto> goto4 = modResults.CreateResultProblemGotoForObject(current);
                        goto4.Text = "Bad module on tile " + Conversions.ToString(_int.X) + ", " + Conversions.ToString(_int.Y) + ".";
                        result.ItemAdd(goto4);
                    }
                }
            }
            finally
            {
                if (enumerator3 is IDisposable)
                {
                    (enumerator3 as IDisposable).Dispose();
                }
            }
            return result;
        }
Example #2
0
        public clsUnitType FindOrCreateUnitType(string Code, clsUnitType.enumType Type, int WallType)
        {
            switch (Type)
            {
                case clsUnitType.enumType.Feature:
                    clsFeatureType current;
                    IEnumerator enumerator;
                    try
                    {
                        enumerator = this.FeatureTypes.GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (clsFeatureType) enumerator.Current;
                            if (current.Code == Code)
                            {
                                return current;
                            }
                        }
                    }
                    finally
                    {
                        if (enumerator is IDisposable)
                        {
                            (enumerator as IDisposable).Dispose();
                        }
                    }
                    current = new clsFeatureType {
                        IsUnknown = true,
                        Code = Code
                    };
                    current.Footprint.X = 1;
                    current.Footprint.Y = 1;
                    return current;

                case clsUnitType.enumType.PlayerStructure:
                    clsStructureType type3;
                    IEnumerator enumerator2;
                    try
                    {
                        enumerator2 = this.StructureTypes.GetEnumerator();
                        while (enumerator2.MoveNext())
                        {
                            type3 = (clsStructureType) enumerator2.Current;
                            if (type3.Code == Code)
                            {
                                if (WallType < 0)
                                {
                                    return type3;
                                }
                                if (type3.WallLink.IsConnected && (type3.WallLink.ArrayPosition == WallType))
                                {
                                    return type3;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (enumerator2 is IDisposable)
                        {
                            (enumerator2 as IDisposable).Dispose();
                        }
                    }
                    type3 = new clsStructureType {
                        IsUnknown = true,
                        Code = Code
                    };
                    type3.Footprint.X = 1;
                    type3.Footprint.Y = 1;
                    return type3;

                case clsUnitType.enumType.PlayerDroid:
                    IEnumerator enumerator3;
                    try
                    {
                        enumerator3 = this.DroidTemplates.GetEnumerator();
                        while (enumerator3.MoveNext())
                        {
                            clsDroidTemplate template = (clsDroidTemplate) enumerator3.Current;
                            if (template.IsTemplate && (template.Code == Code))
                            {
                                return template;
                            }
                        }
                    }
                    finally
                    {
                        if (enumerator3 is IDisposable)
                        {
                            (enumerator3 as IDisposable).Dispose();
                        }
                    }
                    return new clsDroidTemplate { IsUnknown = true, Code = Code };
            }
            return null;
        }
Example #3
0
        public clsResult LoadDirectory(string Path)
        {
            IEnumerator enumerator;
            clsResult result3 = new clsResult("Loading object data from \"" + Path + "\"");
            Path = modProgram.EndWithPathSeperator(Path);
            string str10 = "messages" + Conversions.ToString(modProgram.PlatformPathSeparator) + "strings" + Conversions.ToString(modProgram.PlatformPathSeparator) + "names.txt";
            string str17 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "structures.txt";
            string str5 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "brain.txt";
            string str3 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "body.txt";
            string str13 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "propulsion.txt";
            string str4 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "bodypropulsionimd.txt";
            string str6 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "construction.txt";
            string str15 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "sensor.txt";
            string str14 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "repair.txt";
            string str19 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "templates.txt";
            string str21 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "weapons.txt";
            string str7 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "ecm.txt";
            string str9 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "features.txt";
            string str11 = "pies" + Conversions.ToString(modProgram.PlatformPathSeparator);
            string str16 = str11;
            string str2 = str11;
            string str12 = str11;
            string str22 = str11;
            string str20 = "texpages" + Conversions.ToString(modProgram.PlatformPathSeparator);
            string str = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "assignweapons.txt";
            string str8 = str11;
            string str18 = "stats" + Conversions.ToString(modProgram.PlatformPathSeparator) + "structureweapons.txt";
            modLists.SimpleList<clsTextFile> list = new modLists.SimpleList<clsTextFile>();
            clsTextFile file8 = new clsTextFile {
                SubDirectory = str10,
                UniqueField = 0
            };
            result3.Add(file8.LoadNamesFile(Path));
            if (!file8.CalcUniqueField())
            {
                result3.ProblemAdd("There are two entries for the same code in " + str10 + ".");
            }
            clsTextFile newItem = new clsTextFile {
                SubDirectory = str17,
                FieldCount = 0x19
            };
            list.Add(newItem);
            clsTextFile file4 = new clsTextFile {
                SubDirectory = str5,
                FieldCount = 9
            };
            list.Add(file4);
            clsTextFile file2 = new clsTextFile {
                SubDirectory = str3,
                FieldCount = 0x19
            };
            list.Add(file2);
            clsTextFile file9 = new clsTextFile {
                SubDirectory = str13,
                FieldCount = 12
            };
            list.Add(file9);
            clsTextFile file3 = new clsTextFile {
                SubDirectory = str4,
                FieldCount = 5,
                UniqueField = -1
            };
            list.Add(file3);
            clsTextFile file5 = new clsTextFile {
                SubDirectory = str6,
                FieldCount = 12
            };
            list.Add(file5);
            clsTextFile file11 = new clsTextFile {
                SubDirectory = str15,
                FieldCount = 0x10
            };
            list.Add(file11);
            clsTextFile file10 = new clsTextFile {
                SubDirectory = str14,
                FieldCount = 14
            };
            list.Add(file10);
            clsTextFile file14 = new clsTextFile {
                SubDirectory = str19,
                FieldCount = 12
            };
            list.Add(file14);
            clsTextFile file6 = new clsTextFile {
                SubDirectory = str7,
                FieldCount = 14
            };
            list.Add(file6);
            clsTextFile file7 = new clsTextFile {
                SubDirectory = str9,
                FieldCount = 11
            };
            list.Add(file7);
            clsTextFile file = new clsTextFile {
                SubDirectory = str,
                FieldCount = 5
            };
            list.Add(file);
            clsTextFile file15 = new clsTextFile {
                SubDirectory = str21,
                FieldCount = 0x35
            };
            list.Add(file15);
            clsTextFile file13 = new clsTextFile {
                SubDirectory = str18,
                FieldCount = 6
            };
            list.Add(file13);
            try
            {
                enumerator = list.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    clsTextFile current = (clsTextFile) enumerator.Current;
                    clsResult resultToAdd = current.LoadCommaFile(Path);
                    result3.Add(resultToAdd);
                    if (!resultToAdd.HasProblems)
                    {
                        if (current.CalcIsFieldCountValid())
                        {
                            if (!current.CalcUniqueField())
                            {
                                result3.ProblemAdd("An entry in field " + Conversions.ToString(current.UniqueField) + " was not unique for file " + current.SubDirectory + ".");
                            }
                        }
                        else
                        {
                            result3.ProblemAdd("There were entries with the wrong number of fields for file " + current.SubDirectory + ".");
                        }
                    }
                }
            }
            finally
            {
                if (enumerator is IDisposable)
                {
                    (enumerator as IDisposable).Dispose();
                }
            }
            if (!result3.HasProblems)
            {
                clsUnitType.clsAttachment baseAttachment;
                clsBody body;
                clsECM secm;
                string[] strArray;
                string[] strArray2;
                clsPropulsion propulsion;
                clsSensor sensor;
                string[] files;
                clsWeapon weapon;
                IEnumerator enumerator2;
                IEnumerator enumerator3;
                IEnumerator enumerator4;
                IEnumerator enumerator5;
                IEnumerator enumerator6;
                IEnumerator enumerator7;
                IEnumerator enumerator8;
                IEnumerator enumerator9;
                IEnumerator enumerator10;
                IEnumerator enumerator11;
                IEnumerator enumerator12;
                IEnumerator enumerator13;
                try
                {
                    files = Directory.GetFiles(Path + str20);
                }
                catch (Exception exception1)
                {
                    ProjectData.SetProjectError(exception1);
                    Exception exception = exception1;
                    result3.WarningAdd("Unable to access texture pages.");
                    files = new string[0];
                    ProjectData.ClearProjectError();
                }
                System.Drawing.Bitmap resultBitmap = null;
                foreach (string str23 in files)
                {
                    if (Strings.Right(str23, 4).ToLower() == ".png")
                    {
                        clsResult result5 = new clsResult("Loading texture page \"" + str23 + "\"");
                        if (File.Exists(str23))
                        {
                            modProgram.sResult result = modBitmap.LoadBitmap(str23, ref resultBitmap);
                            clsTexturePage page = new clsTexturePage();
                            if (result.Success)
                            {
                                modBitmap.sBitmapGLTexture texture;
                                result5.Take(modBitmap.BitmapIsGLCompatible(resultBitmap));
                                texture.MagFilter = TextureMagFilter.Nearest;
                                texture.MinFilter = TextureMinFilter.Nearest;
                                texture.TextureNum = 0;
                                texture.MipMapLevel = 0;
                                texture.Texture = resultBitmap;
                                texture.Perform();
                                page.GLTexture_Num = texture.TextureNum;
                            }
                            else
                            {
                                result5.WarningAdd(result.Problem);
                            }
                            int num = Strings.InStrRev(str23, Conversions.ToString(modProgram.PlatformPathSeparator), -1, CompareMethod.Binary);
                            page.FileTitle = Strings.Mid(str23, num + 1, (str23.Length - 4) - num);
                            this.TexturePages.Add(page);
                        }
                        else
                        {
                            result5.WarningAdd("Texture page missing (" + str23 + ").");
                        }
                        result3.Add(result5);
                    }
                }
                modLists.SimpleList<clsPIE> list2 = new modLists.SimpleList<clsPIE>();
                try
                {
                    strArray2 = Directory.GetFiles(Path + str11);
                }
                catch (Exception exception3)
                {
                    ProjectData.SetProjectError(exception3);
                    Exception exception2 = exception3;
                    result3.WarningAdd("Unable to access PIE files.");
                    strArray2 = new string[0];
                    ProjectData.ClearProjectError();
                }
                foreach (string str23 in strArray2)
                {
                    modProgram.sSplitPath path = new modProgram.sSplitPath(str23);
                    if (path.FileExtension.ToLower() == "pie")
                    {
                        clsPIE spie = new clsPIE {
                            Path = str23,
                            LCaseFileTitle = path.FileTitle.ToLower()
                        };
                        list2.Add(spie);
                    }
                }
                try
                {
                    enumerator2 = file2.ResultData.GetEnumerator();
                    while (enumerator2.MoveNext())
                    {
                        strArray = (string[]) enumerator2.Current;
                        body = new clsBody();
                        body.ObjectDataLink.Connect(this.Bodies);
                        body.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, body, result3);
                        modIO.InvariantParse_int(strArray[6], ref body.Hitpoints);
                        body.Designable = strArray[0x18] != "0";
                        body.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[7].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator2 is IDisposable)
                    {
                        (enumerator2 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator3 = file9.ResultData.GetEnumerator();
                    while (enumerator3.MoveNext())
                    {
                        strArray = (string[]) enumerator3.Current;
                        propulsion = new clsPropulsion(this.Bodies.Count);
                        propulsion.ObjectDataLink.Connect(this.Propulsions);
                        propulsion.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, propulsion, result3);
                        modIO.InvariantParse_int(strArray[7], ref propulsion.HitPoints);
                        propulsion.Designable = strArray[11] != "0";
                    }
                }
                finally
                {
                    if (enumerator3 is IDisposable)
                    {
                        (enumerator3 as IDisposable).Dispose();
                    }
                }
                BodyProp[,] propArray = new BodyProp[(this.Bodies.Count - 1) + 1, (this.Propulsions.Count - 1) + 1];
                int num10 = this.Bodies.Count - 1;
                for (int i = 0; i <= num10; i++)
                {
                    int num11 = this.Propulsions.Count - 1;
                    for (int k = 0; k <= num11; k++)
                    {
                        propArray[i, k] = new BodyProp();
                        propArray[i, k].LeftPIE = "0";
                        propArray[i, k].RightPIE = "0";
                    }
                }
                try
                {
                    enumerator4 = file3.ResultData.GetEnumerator();
                    while (enumerator4.MoveNext())
                    {
                        strArray = (string[]) enumerator4.Current;
                        body = this.FindBodyCode(strArray[0]);
                        propulsion = this.FindPropulsionCode(strArray[1]);
                        if ((body != null) & (propulsion != null))
                        {
                            if (strArray[2] != "0")
                            {
                                propArray[body.ObjectDataLink.ArrayPosition, propulsion.ObjectDataLink.ArrayPosition].LeftPIE = strArray[2].ToLower();
                            }
                            if (strArray[3] != "0")
                            {
                                propArray[body.ObjectDataLink.ArrayPosition, propulsion.ObjectDataLink.ArrayPosition].RightPIE = strArray[3].ToLower();
                            }
                        }
                    }
                }
                finally
                {
                    if (enumerator4 is IDisposable)
                    {
                        (enumerator4 as IDisposable).Dispose();
                    }
                }
                int num12 = this.Propulsions.Count - 1;
                for (int j = 0; j <= num12; j++)
                {
                    propulsion = this.Propulsions[j];
                    int num13 = this.Bodies.Count - 1;
                    for (int m = 0; m <= num13; m++)
                    {
                        body = this.Bodies[m];
                        propulsion.Bodies[m].LeftAttachment = new clsUnitType.clsAttachment();
                        propulsion.Bodies[m].LeftAttachment.Models.Add(this.GetModelForPIE(list2, propArray[m, j].LeftPIE, result3));
                        propulsion.Bodies[m].RightAttachment = new clsUnitType.clsAttachment();
                        propulsion.Bodies[m].RightAttachment.Models.Add(this.GetModelForPIE(list2, propArray[m, j].RightPIE, result3));
                    }
                }
                try
                {
                    enumerator5 = file5.ResultData.GetEnumerator();
                    while (enumerator5.MoveNext())
                    {
                        strArray = (string[]) enumerator5.Current;
                        clsConstruct component = new clsConstruct();
                        component.ObjectDataLink.Connect(this.Constructors);
                        component.TurretObjectDataLink.Connect(this.Turrets);
                        component.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, component, result3);
                        component.Designable = strArray[11] != "0";
                        component.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[8].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator5 is IDisposable)
                    {
                        (enumerator5 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator6 = file15.ResultData.GetEnumerator();
                    while (enumerator6.MoveNext())
                    {
                        strArray = (string[]) enumerator6.Current;
                        weapon = new clsWeapon();
                        weapon.ObjectDataLink.Connect(this.Weapons);
                        weapon.TurretObjectDataLink.Connect(this.Turrets);
                        weapon.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, weapon, result3);
                        modIO.InvariantParse_int(strArray[7], ref weapon.HitPoints);
                        weapon.Designable = strArray[0x33] != "0";
                        weapon.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[8].ToLower(), result3));
                        weapon.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[9].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator6 is IDisposable)
                    {
                        (enumerator6 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator7 = file11.ResultData.GetEnumerator();
                    while (enumerator7.MoveNext())
                    {
                        strArray = (string[]) enumerator7.Current;
                        sensor = new clsSensor();
                        sensor.ObjectDataLink.Connect(this.Sensors);
                        sensor.TurretObjectDataLink.Connect(this.Turrets);
                        sensor.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, sensor, result3);
                        modIO.InvariantParse_int(strArray[7], ref sensor.HitPoints);
                        sensor.Designable = strArray[15] != "0";
                        string str27 = strArray[11].ToLower();
                        if (str27 == "turret")
                        {
                            sensor.Location = clsSensor.enumLocation.Turret;
                        }
                        else if (str27 == "default")
                        {
                            sensor.Location = clsSensor.enumLocation.Invisible;
                        }
                        else
                        {
                            sensor.Location = clsSensor.enumLocation.Invisible;
                        }
                        sensor.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[8].ToLower(), result3));
                        sensor.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[9].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator7 is IDisposable)
                    {
                        (enumerator7 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator8 = file10.ResultData.GetEnumerator();
                    while (enumerator8.MoveNext())
                    {
                        strArray = (string[]) enumerator8.Current;
                        clsRepair repair = new clsRepair();
                        repair.ObjectDataLink.Connect(this.Repairs);
                        repair.TurretObjectDataLink.Connect(this.Turrets);
                        repair.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, repair, result3);
                        repair.Designable = strArray[13] != "0";
                        repair.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[9].ToLower(), result3));
                        repair.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[10].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator8 is IDisposable)
                    {
                        (enumerator8 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator9 = file4.ResultData.GetEnumerator();
                    while (enumerator9.MoveNext())
                    {
                        strArray = (string[]) enumerator9.Current;
                        clsBrain brain = new clsBrain();
                        brain.ObjectDataLink.Connect(this.Brains);
                        brain.TurretObjectDataLink.Connect(this.Turrets);
                        brain.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, brain, result3);
                        brain.Designable = true;
                        weapon = this.FindWeaponCode(strArray[7]);
                        if (weapon != null)
                        {
                            brain.Weapon = weapon;
                            brain.Attachment = weapon.Attachment;
                        }
                    }
                }
                finally
                {
                    if (enumerator9 is IDisposable)
                    {
                        (enumerator9 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator10 = file6.ResultData.GetEnumerator();
                    while (enumerator10.MoveNext())
                    {
                        strArray = (string[]) enumerator10.Current;
                        secm = new clsECM();
                        secm.ObjectDataLink.Connect(this.ECMs);
                        secm.TurretObjectDataLink.Connect(this.Turrets);
                        secm.Code = strArray[0];
                        this.SetComponentName(file8.ResultData, secm, result3);
                        modIO.InvariantParse_int(strArray[7], ref secm.HitPoints);
                        secm.Designable = false;
                        secm.Attachment.Models.Add(this.GetModelForPIE(list2, strArray[8].ToLower(), result3));
                    }
                }
                finally
                {
                    if (enumerator10 is IDisposable)
                    {
                        (enumerator10 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator11 = file7.ResultData.GetEnumerator();
                    while (enumerator11.MoveNext())
                    {
                        strArray = (string[]) enumerator11.Current;
                        clsFeatureType featureType = new clsFeatureType();
                        featureType.UnitType_ObjectDataLink.Connect(this.UnitTypes);
                        featureType.FeatureType_ObjectDataLink.Connect(this.FeatureTypes);
                        featureType.Code = strArray[0];
                        if (strArray[7] == "OIL RESOURCE")
                        {
                            featureType.FeatureType = clsFeatureType.enumFeatureType.OilResource;
                        }
                        this.SetFeatureName(file8.ResultData, featureType, result3);
                        if (!modIO.InvariantParse_int(strArray[1], ref featureType.Footprint.X))
                        {
                            result3.WarningAdd("Feature footprint-x was not an integer for " + featureType.Code + ".");
                        }
                        if (!modIO.InvariantParse_int(strArray[2], ref featureType.Footprint.Y))
                        {
                            result3.WarningAdd("Feature footprint-y was not an integer for " + featureType.Code + ".");
                        }
                        featureType.BaseAttachment = new clsUnitType.clsAttachment();
                        baseAttachment = featureType.BaseAttachment;
                        name = strArray[6].ToLower();
                        baseAttachment.CreateAttachment().Models.Add(this.GetModelForPIE(list2, name, result3));
                    }
                }
                finally
                {
                    if (enumerator11 is IDisposable)
                    {
                        (enumerator11 as IDisposable).Dispose();
                    }
                }
                try
                {
                    enumerator12 = newItem.ResultData.GetEnumerator();
                    while (enumerator12.MoveNext())
                    {
                        modMath.sXY_int _int;
                        strArray = (string[]) enumerator12.Current;
                        string str25 = strArray[0];
                        string str26 = strArray[1];
                        string[] strArray4 = strArray[0x15].ToLower().Split(new char[] { '@' });
                        string str24 = strArray[0x16].ToLower();
                        if (!modIO.InvariantParse_int(strArray[5], ref _int.X))
                        {
                            result3.WarningAdd("Structure footprint-x was not an integer for " + str25 + ".");
                        }
                        if (!modIO.InvariantParse_int(strArray[6], ref _int.Y))
                        {
                            result3.WarningAdd("Structure footprint-y was not an integer for " + str25 + ".");
                        }
                        if ((str26 != "WALL") | (strArray4.GetLength(0) != 4))
                        {
                            clsStructureType structureType = new clsStructureType();
                            structureType.UnitType_ObjectDataLink.Connect(this.UnitTypes);
                            structureType.StructureType_ObjectDataLink.Connect(this.StructureTypes);
                            structureType.Code = str25;
                            this.SetStructureName(file8.ResultData, structureType, result3);
                            structureType.Footprint = _int;
                            string str28 = str26;
                            if (str28 == "DEMOLISH")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Demolish;
                            }
                            else if (str28 == "WALL")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Wall;
                            }
                            else if (str28 == "CORNER WALL")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.CornerWall;
                            }
                            else if (str28 == "FACTORY")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Factory;
                            }
                            else if (str28 == "CYBORG FACTORY")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.CyborgFactory;
                            }
                            else if (str28 == "VTOL FACTORY")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.VTOLFactory;
                            }
                            else if (str28 == "COMMAND")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Command;
                            }
                            else if (str28 == "HQ")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.HQ;
                            }
                            else if (str28 == "DEFENSE")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Defense;
                            }
                            else if (str28 == "POWER GENERATOR")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.PowerGenerator;
                            }
                            else if (str28 == "POWER MODULE")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.PowerModule;
                            }
                            else if (str28 == "RESEARCH")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Research;
                            }
                            else if (str28 == "RESEARCH MODULE")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.ResearchModule;
                            }
                            else if (str28 == "FACTORY MODULE")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.FactoryModule;
                            }
                            else if (str28 == "DOOR")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.DOOR;
                            }
                            else if (str28 == "REPAIR FACILITY")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.RepairFacility;
                            }
                            else if (str28 == "SAT UPLINK")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.DOOR;
                            }
                            else if (str28 == "REARM PAD")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.RearmPad;
                            }
                            else if (str28 == "MISSILE SILO")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.MissileSilo;
                            }
                            else if (str28 == "RESOURCE EXTRACTOR")
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.ResourceExtractor;
                            }
                            else
                            {
                                structureType.StructureType = clsStructureType.enumStructureType.Unknown;
                            }
                            baseAttachment = structureType.BaseAttachment;
                            if (strArray4.GetLength(0) > 0)
                            {
                                baseAttachment.Models.Add(this.GetModelForPIE(list2, strArray4[0], result3));
                            }
                            structureType.StructureBasePlate = this.GetModelForPIE(list2, str24, result3);
                            if ((baseAttachment.Models.Count == 1) && (baseAttachment.Models[0].ConnectorCount >= 1))
                            {
                                modMath.sXYZ_sng _sng = baseAttachment.Models[0].Connectors[0];
                                modLists.SimpleList<string[]> rowsWithValue = this.GetRowsWithValue(file13.ResultData, structureType.Code);
                                if (rowsWithValue.Count > 0)
                                {
                                    weapon = this.FindWeaponCode(rowsWithValue[0][1]);
                                }
                                else
                                {
                                    weapon = null;
                                }
                                secm = this.FindECMCode(strArray[0x12]);
                                sensor = this.FindSensorCode(strArray[0x13]);
                                if ((weapon != null) && (weapon.Code != "ZNULLWEAPON"))
                                {
                                    baseAttachment.CopyAttachment(weapon.Attachment).Pos_Offset = _sng;
                                }
                                if ((secm != null) && (secm.Code != "ZNULLECM"))
                                {
                                    baseAttachment.CopyAttachment(secm.Attachment).Pos_Offset = _sng;
                                }
                                if ((sensor != null) && (sensor.Code != "ZNULLSENSOR"))
                                {
                                    baseAttachment.CopyAttachment(sensor.Attachment).Pos_Offset = _sng;
                                }
                            }
                            continue;
                        }
                        clsWallType wallType = new clsWallType();
                        wallType.WallType_ObjectDataLink.Connect(this.WallTypes);
                        wallType.Code = str25;
                        this.SetWallName(file8.ResultData, wallType, result3);
                        clsModel model = this.GetModelForPIE(list2, str24, result3);
                        int index = 0;
                        do
                        {
                            clsStructureType type4 = new clsStructureType();
                            type4.UnitType_ObjectDataLink.Connect(this.UnitTypes);
                            type4.StructureType_ObjectDataLink.Connect(this.StructureTypes);
                            type4.WallLink.Connect(wallType.Segments);
                            type4.Code = str25;
                            name = wallType.Name;
                            switch (index)
                            {
                                case 0:
                                    name = name + " - ";
                                    break;

                                case 1:
                                    name = name + " + ";
                                    break;

                                case 2:
                                    name = name + " T ";
                                    break;

                                case 3:
                                    name = name + " L ";
                                    break;
                            }
                            type4.Name = name;
                            type4.Footprint = _int;
                            type4.StructureType = clsStructureType.enumStructureType.Wall;
                            baseAttachment = type4.BaseAttachment;
                            name = strArray4[index];
                            baseAttachment.Models.Add(this.GetModelForPIE(list2, name, result3));
                            type4.StructureBasePlate = model;
                            index++;
                        }
                        while (index <= 3);
                    }
                }
                finally
                {
                    if (enumerator12 is IDisposable)
                    {
                        (enumerator12 as IDisposable).Dispose();
                    }
                }
                int num2 = 0;
                try
                {
                    enumerator13 = file14.ResultData.GetEnumerator();
                    while (enumerator13.MoveNext())
                    {
                        strArray = (string[]) enumerator13.Current;
                        clsDroidTemplate template = new clsDroidTemplate();
                        template.UnitType_ObjectDataLink.Connect(this.UnitTypes);
                        template.DroidTemplate_ObjectDataLink.Connect(this.DroidTemplates);
                        template.Code = strArray[0];
                        this.SetTemplateName(file8.ResultData, template, result3);
                        string str29 = strArray[9];
                        if (str29 == "ZNULLDROID")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_Null;
                        }
                        else if (str29 == "DROID")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_Droid;
                        }
                        else if (str29 == "CYBORG")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_Cyborg;
                        }
                        else if (str29 == "CYBORG_CONSTRUCT")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_CyborgConstruct;
                        }
                        else if (str29 == "CYBORG_REPAIR")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_CyborgRepair;
                        }
                        else if (str29 == "CYBORG_SUPER")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_CyborgSuper;
                        }
                        else if (str29 == "TRANSPORTER")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_Transporter;
                        }
                        else if (str29 == "PERSON")
                        {
                            template.TemplateDroidType = modProgram.TemplateDroidType_Person;
                        }
                        else
                        {
                            template.TemplateDroidType = null;
                            result3.WarningAdd("Template " + template.GetDisplayTextCode() + " had an unrecognised type.");
                        }
                        clsDroidDesign.sLoadPartsArgs args = new clsDroidDesign.sLoadPartsArgs {
                            Body = this.FindBodyCode(strArray[2]),
                            Brain = this.FindBrainCode(strArray[3]),
                            Construct = this.FindConstructorCode(strArray[4]),
                            ECM = this.FindECMCode(strArray[5]),
                            Propulsion = this.FindPropulsionCode(strArray[7]),
                            Repair = this.FindRepairCode(strArray[8]),
                            Sensor = this.FindSensorCode(strArray[10])
                        };
                        modLists.SimpleList<string[]> list4 = this.GetRowsWithValue(file.ResultData, template.Code);
                        if (list4.Count > 0)
                        {
                            name = list4[0][1];
                            if (name != "NULL")
                            {
                                args.Weapon1 = this.FindWeaponCode(name);
                            }
                            name = list4[0][2];
                            if (name != "NULL")
                            {
                                args.Weapon2 = this.FindWeaponCode(name);
                            }
                            name = list4[0][3];
                            if (name != "NULL")
                            {
                                args.Weapon3 = this.FindWeaponCode(name);
                            }
                        }
                        if (!template.LoadParts(args))
                        {
                            if (num2 < 0x10)
                            {
                                result3.WarningAdd("Template " + template.GetDisplayTextCode() + " had multiple conflicting turrets.");
                            }
                            num2++;
                        }
                    }
                }
                finally
                {
                    if (enumerator13 is IDisposable)
                    {
                        (enumerator13 as IDisposable).Dispose();
                    }
                }
                if (num2 > 0)
                {
                    result3.WarningAdd(Conversions.ToString(num2) + " templates had multiple conflicting turrets.");
                }
            }
            return result3;
        }
Example #4
0
 public void SetFeatureName(modLists.SimpleList<string[]> Names, clsFeatureType FeatureType, clsResult Result)
 {
     modLists.SimpleList<string[]> rowsWithValue = this.GetRowsWithValue(Names, FeatureType.Code);
     if (rowsWithValue.Count == 0)
     {
         Result.WarningAdd("No name for feature type " + FeatureType.Code + ".");
     }
     else
     {
         FeatureType.Name = rowsWithValue[0][1];
     }
 }