public static int GetNextVacantPosition(RMGenPart.eGender gender, RMGenPart.GenPartType partType, int curPosition)
            {
                string pathToVar   = PMFileSystem.Generator.Variation.Root + "\\" + gender.GetContainingDirectoryName();
                string partToCount = pathToVar + "\\" + RMPConstants.GenFileNamePrefixANDSuffix.VARIATION + "_" + partType.ToParsableXMLString();


                Config cfgWithLowestInt      = Config.GetConfigFileWithLowestInt(SpecialNumberedParts, gender, partType, curPosition);
                bool   nextIntAlreadyChecked = false;
                int    nextInt = curPosition + 1;

                if (cfgWithLowestInt == null || cfgWithLowestInt.Integer > nextInt)
                {
                    nextIntAlreadyChecked = true;
                }

                string partToCheck = partToCount + RMGenFile.FormatPosition(nextInt) + RMPConstants.GenFileNamePrefixANDSuffix.PNG;

                if (File.Exists(partToCheck))
                {
                    return(GetNextVacantPosition(gender, partType, nextInt));
                }

                if (!nextIntAlreadyChecked && ShouldSkipPosition(gender, partType, nextInt))
                {
                    return(GetNextVacantPosition(gender, partType, nextInt));
                }

                return(nextInt);
            }
 public static bool ShouldSkipPosition(RMGenPart.eGender gender, RMGenPart.GenPartType partType, int position)
 {
     if (Config.RetrieveConfigForPartFromList(SpecialNumberedParts, gender, partType, position) != null)
     {
         return(true);
     }
     return(false);
 }
 public Config(SimpleDatabaseTokenList tokenList)
 {
     if (tokenList.Tokens.Count >= 3)
     {
         Gender = Gender.ParseXMLString(tokenList.Tokens[0]);
         Part   = Part.ParseXMLString(tokenList.Tokens[1]);
         int.TryParse(tokenList.Tokens[2], out Integer);
     }
 }
            public static int GetPositionFloorOfPart(RMGenPart.eGender gender, RMGenPart.GenPartType partType)
            {
                Config cfg = Config.RetrieveConfigForPartFromList(PartsWithNonDefaultFloor, gender, partType);

                if (cfg != null)
                {
                    return(cfg.Integer);
                }
                return(1);
            }
Exemplo n.º 5
0
        internal static int CountPartOfType(this IEnumerable <RMGenPart> parts, RMGenPart.GenPartType partType, RMGenPart.eGender gender)
        {
            int counter = 0;

            foreach (RMGenPart part in parts)
            {
                if (part.PartType == partType && part.Gender == gender)
                {
                    ++counter;
                }
            }
            return(counter);
        }
Exemplo n.º 6
0
        void DoParse()
        {
            string tString = curString.ToString();

            if (curPos == RMGenFile.FileNameInfo.Type)
            {
                Part = Part.ParseLowerCaseString(tString);
            }
            else if (curPos == RMGenFile.FileNameInfo.BaseOrder)
            {
                int tInt;
                if (int.TryParse(tString, out tInt))
                {
                    BaseOrder = tInt;
                }
                curPos = RMGenFile.FileNameInfo.Position;
            }
            else if (curPos == RMGenFile.FileNameInfo.Position)
            {
                int tInt;
                if (int.TryParse(tString, out tInt))
                {
                    Position = tInt;
                }
                curPos = RMGenFile.FileNameInfo.Waiting;
            }
            else if (curPos == RMGenFile.FileNameInfo.Order)
            {
                int tInt;
                if (int.TryParse(tString, out tInt))
                {
                    Order = tInt;
                }
                else
                {
                    IsAcFile = true;
                }
                curPos = RMGenFile.FileNameInfo.Waiting;
            }
            else if (curPos == RMGenFile.FileNameInfo.Colour)
            {
                int tInt;
                if (int.TryParse(tString, out tInt))
                {
                    Colour = tInt;
                }
                curPos = RMGenFile.FileNameInfo.Waiting;
            }
            curString = new StringBuilder();
        }
            public static int GetNextIntPosition(RMGenPart.eGender gender, RMGenPart.GenPartType partType, int curPosition)
            {
                Config cfgWithLowestInt = Config.GetConfigFileWithLowestInt(SpecialNumberedParts, gender, partType, curPosition);
                int    nextInt          = curPosition + 1;

                if (cfgWithLowestInt == null || cfgWithLowestInt.Integer > nextInt)
                {
                    return(nextInt);
                }

                if (ShouldSkipPosition(gender, partType, nextInt))
                {
                    return(GetNextIntPosition(gender, partType, nextInt));
                }

                return(nextInt);
            }
Exemplo n.º 8
0
        internal static RMGenPart GetPartByInternalPosition(this IEnumerable <RMGenPart> listOfParts, RMGenPart.GenPartType partType, RMGenPart.eGender gender, int position)
        {
            if (listOfParts == null)
            {
                return(null);
            }
            foreach (RMGenPart part in listOfParts)
            {
                if (part.PartType == partType && part.Gender == gender && part.implicitID == position)
                {
                    return(part);
                }
            }

            return(null);
        }
Exemplo n.º 9
0
        internal static RMGenPart GetLowestPartByInternalPosition(this IEnumerable <RMGenPart> listOfPart, RMGenPart.GenPartType partType, RMGenPart.eGender gender)
        {
            if (listOfPart == null)
            {
                return(null);
            }
            RMGenPart retVal = null;

            foreach (RMGenPart part in listOfPart)
            {
                if (part.PartType == partType && part.Gender == gender)
                {
                    if (retVal == null)
                    {
                        retVal = part;
                    }
                    else if (part.implicitID < retVal.implicitID)
                    {
                        retVal = part;
                    }
                }
            }

            return(retVal);
        }
Exemplo n.º 10
0
                internal static Config GetConfigFileWithLowestInt(IEnumerable <Config> ListOfConfigs, RMGenPart.eGender Gender, RMGenPart.GenPartType partType, int floor)
                {
                    if (ListOfConfigs == null)
                    {
                        return(null);
                    }

                    Config currentLowestCFG = null;

                    foreach (Config cfg in ListOfConfigs)
                    {
                        if (cfg.Gender == Gender && cfg.Part == partType)
                        {
                            if (currentLowestCFG == null && cfg.Integer > floor)
                            {
                                currentLowestCFG = cfg;
                            }
                            else if (currentLowestCFG != null && currentLowestCFG.Integer > cfg.Integer && cfg.Integer > floor)
                            {
                                currentLowestCFG = cfg;
                            }
                        }
                    }
                    return(currentLowestCFG);
                }
Exemplo n.º 11
0
 internal static Config RetrieveConfigForPartFromList(IEnumerable <Config> ListOfConfigs, RMGenPart.eGender Gender, RMGenPart.GenPartType partType, int position)
 {
     if (ListOfConfigs == null)
     {
         return(null);
     }
     foreach (Config cfg in ListOfConfigs)
     {
         if (cfg.Gender == Gender && cfg.Part == partType && cfg.Integer == position)
         {
             return(cfg);
         }
     }
     return(null);
 }
        public static RMGenPart.GenPartType ParseXMLString(this RMGenPart.GenPartType partType, string stringToParse)
        {
            switch (stringToParse)
            {
            case RMPConstants.GenPartsType.BEARD:
                return(RMGenPart.GenPartType.Beard);

            case RMPConstants.GenPartsType.ACCESSORY_A:
                return(RMGenPart.GenPartType.Accessory_A);

            case RMPConstants.GenPartsType.ACCESSORY_B:
                return(RMGenPart.GenPartType.Accessory_B);

            case RMPConstants.GenPartsType.BEAST_EARS:
                return(RMGenPart.GenPartType.Beast_Ears);

            case RMPConstants.GenPartsType.BODY:
                return(RMGenPart.GenPartType.Body);

            case RMPConstants.GenPartsType.CLOAK:
                return(RMGenPart.GenPartType.Cloak);

            case RMPConstants.GenPartsType.CLOTHING:
                return(RMGenPart.GenPartType.Clothing);

            case RMPConstants.GenPartsType.EARS:
                return(RMGenPart.GenPartType.Ears);

            case RMPConstants.GenPartsType.EYEBROWS:
                return(RMGenPart.GenPartType.Eyebrows);

            case RMPConstants.GenPartsType.EYES:
                return(RMGenPart.GenPartType.Eyes);

            case RMPConstants.GenPartsType.FACE:
                return(RMGenPart.GenPartType.Face);

            case RMPConstants.GenPartsType.FACIAL_MARK:
                return(RMGenPart.GenPartType.Facial_Mark);

            case RMPConstants.GenPartsType.FRONT_HAIR:
                return(RMGenPart.GenPartType.Front_Hair);

            case RMPConstants.GenPartsType.GLASSES:
                return(RMGenPart.GenPartType.Glasses);

            case RMPConstants.GenPartsType.MOUTH:
                return(RMGenPart.GenPartType.Mouth);

            case RMPConstants.GenPartsType.NOSE:
                return(RMGenPart.GenPartType.Nose);

            case RMPConstants.GenPartsType.REAR_HAIR:
                return(RMGenPart.GenPartType.Rear_Hair);

            case RMPConstants.GenPartsType.TAIL:
                return(RMGenPart.GenPartType.Tail);

            case RMPConstants.GenPartsType.WING:
                return(RMGenPart.GenPartType.Wing);
            }
            return(RMGenPart.GenPartType.None);
        }
        public static string ToParsableXMLString(this RMGenPart.GenPartType genPartType)
        {
            switch (genPartType)
            {
            case RMGenPart.GenPartType.Accessory_A:
                return(RMPConstants.GenPartsType.ACCESSORY_A);

            case RMGenPart.GenPartType.Accessory_B:
                return(RMPConstants.GenPartsType.ACCESSORY_B);

            case RMGenPart.GenPartType.Beard:
                return(RMPConstants.GenPartsType.BEARD);

            case RMGenPart.GenPartType.Beast_Ears:
                return(RMPConstants.GenPartsType.BEAST_EARS);

            case RMGenPart.GenPartType.Body:
                return(RMPConstants.GenPartsType.BODY);

            case RMGenPart.GenPartType.Cloak:
                return(RMPConstants.GenPartsType.CLOAK);

            case RMGenPart.GenPartType.Clothing:
                return(RMPConstants.GenPartsType.CLOTHING);

            case RMGenPart.GenPartType.Ears:
                return(RMPConstants.GenPartsType.EARS);

            case RMGenPart.GenPartType.Eyebrows:
                return(RMPConstants.GenPartsType.EYEBROWS);

            case RMGenPart.GenPartType.Eyes:
                return(RMPConstants.GenPartsType.EYES);

            case RMGenPart.GenPartType.Face:
                return(RMPConstants.GenPartsType.FACE);

            case RMGenPart.GenPartType.Facial_Mark:
                return(RMPConstants.GenPartsType.FACIAL_MARK);

            case RMGenPart.GenPartType.Front_Hair:
                return(RMPConstants.GenPartsType.FRONT_HAIR);

            case RMGenPart.GenPartType.Glasses:
                return(RMPConstants.GenPartsType.GLASSES);

            case RMGenPart.GenPartType.Mouth:
                return(RMPConstants.GenPartsType.MOUTH);

            case RMGenPart.GenPartType.Nose:
                return(RMPConstants.GenPartsType.NOSE);

            case RMGenPart.GenPartType.Rear_Hair:
                return(RMPConstants.GenPartsType.REAR_HAIR);

            case RMGenPart.GenPartType.Tail:
                return(RMPConstants.GenPartsType.TAIL);

            case RMGenPart.GenPartType.Wing:
                return(RMPConstants.GenPartsType.WING);

            default:
                return(string.Empty);
            }
        }
        static void PerformRenumberOnPart(RMGeneratorCollection collection, RMGenPart.eGender gender, RMGenPart.GenPartType partType, ref List <ComparedPath> comparedPaths, string rootPath, string _namespace)
        {
            int       floorPositionValue = Precision.GetPositionFloorOfPart(gender, partType);
            RMGenPart nextLowestGenPart  = collection.Parts.GetPartByInternalPosition(partType, gender, floorPositionValue);

            if (nextLowestGenPart == null)
            {
                nextLowestGenPart = collection.Parts.GetLowestPartByInternalPosition(partType, gender);
                if (nextLowestGenPart == null)
                {
                    return;
                }
                nextLowestGenPart.implicitID = floorPositionValue;
                PerformRenumberOnPartsFile(nextLowestGenPart, ref comparedPaths, rootPath, _namespace);
            }
            RMGenPart prevLowestGenPart;

            while (true)
            {
                prevLowestGenPart = nextLowestGenPart;
                collection.Parts.Remove(nextLowestGenPart);
                nextLowestGenPart = collection.Parts.GetLowestPartByInternalPosition(partType, gender);
                if (nextLowestGenPart == null)
                {
                    break;
                }
                if ((nextLowestGenPart.implicitID - prevLowestGenPart.implicitID) > 1)
                {
                    if (Precision.ShouldSkipPosition(gender, partType, prevLowestGenPart.implicitID + 1))
                    {
                        int nextPosition = Precision.GetNextIntPosition(gender, partType, prevLowestGenPart.implicitID);
                        if (nextPosition == nextLowestGenPart.implicitID)
                        {
                            continue;
                        }
                    }
                    nextLowestGenPart.implicitID = Precision.GetNextIntPosition(gender, partType, prevLowestGenPart.implicitID);
                    PerformRenumberOnPartsFile(nextLowestGenPart, ref comparedPaths, rootPath, _namespace);
                }
            }
        }