Example #1
0
 public string GetRandomWord(LongRandom rand, string subtype, string className, WordFormat format)
 {
     int subIndex = LookForSubtype(subtype);
     if (subIndex == -1)
     {
         return Error("SubtypeNotFound->"+subtype);
     }
     int index = PickByWeight(className, rand);
     if (className == "")
     {
         if (subIndex > Words[index].Length - 1)
         {
             return Error("SubtypeOutOfRange");
         }
         return Format(Words[index][subIndex], format);
     }
     else
     {
         if (!this.Classes.ContainsKey(className))
         {
             return Error("ClassNotFound->"+className);
         }
         return Format(Words[this.Classes[className][index]][subIndex], format);
     }
 }
Example #2
0
        public int GetRandomIndex(LongRandom rand, string className)
        {
            if (className == "")
            {
                return rand.Next(0, this.Words.Length);
            }
            else
            {
                if (!this.Classes.ContainsKey(className))
                {
                    return -1;
                }

                return this.Classes[className][rand.Next(0, this.Classes[className].Count)];
            }
        }
Example #3
0
        public MoistGenerator(bool allowFlagged, string[] mount)
        {
            rand = new LongRandom();
            errorLog = new StringBuilder();
            flags = new List<string>();
            wordBank = new Dictionary<char,WordList>();
            patternBank = new Dictionary<string,PatternList>();
            macroBank = new Dictionary<string, string>();
            globalBank = new Dictionary<string, string>();
            globalValues = new Dictionary<string, string>();
            oIntros = new List<string>();
            oBodies = new List<string>();
            oEndings = new List<string>();

            foreach(string addon in mount)
            {
                Mount(addon);
            }
        }
Example #4
0
 public static Rectangle GetRandomRect(this Bitmap bitmap, int minWidth, int minHeight, LongRandom rand)
 {
     if (minWidth >= bitmap.Width && minHeight >= bitmap.Height) return new Rectangle(new Point(0, 0), bitmap.Size);
     int left = rand.Next(0, bitmap.Width - minWidth);
     int top = rand.Next(0, bitmap.Height - minHeight);
     int height = rand.Next(minHeight, bitmap.Height - top);
     int width = rand.Next(minWidth, bitmap.Width - left);
     return new Rectangle(left, top, width, height);
 }
Example #5
0
        private void GenerateFromPattern(StringBuilder stream, string rawPattern)
        {
            CharReader reader = new CharReader(TranslateDefs(rawPattern, "", ""), 0);

            // Output stuff
            WordFormat currentFormat = WordFormat.None;
            string buffer = "";

            // Input stuff
            char c = ' ';
            char prev = ' '; // This is only used by the Proper format mode to determine the start of a word

            // A/An conversion stuff
            int anIndex = -1;
            WordFormat anFormat = WordFormat.None;

            // Selector stuff
            int uniformSeedSalt = rand.Next(0, 1000000);
            List<int> activeSelectors = new List<int>();
            List<int> selectorUniformIDs = new List<int>();
            int currentUniformID = -1;

            // Word lock stuff
            Dictionary<string, Dictionary<string, int>> locks = new Dictionary<string, Dictionary<string, int>>();

            // Repeater stuff
            List<RepeaterInstance> repeaters = new List<RepeaterInstance>();

            // Volatile flags
            List<string> vflags = new List<string>();

            while (!reader.EndOfString) // Read through pattern until we reach the end
            {
                prev = c;
                c = reader.ReadChar();
                string className = "";
                string subType = "";

                #region Frequency indicators
                if (Char.IsNumber(c)) // Check if frequency indicator is here. Example: 40%{ +n[plural] are +A. }
                {
                    int oldPos = reader.Position;
                    int percentIndex = reader.Source.IndexOf('%', reader.Position);
                    int nextSpace = reader.Source.IndexOf(' ', reader.Position);
                    if (percentIndex > -1 && (percentIndex < nextSpace || nextSpace == -1))
                    {
                        reader.Position--; // Revert reading of first digit
                        string percentStr = reader.ReadString(percentIndex - reader.Position);
                        int percent;
                        if (!int.TryParse(percentStr, out percent))
                        {
                            Error("Frequency indicator percent value was not a number.", reader);
                            return;
                        }

                        if (percent > 100)
                        {
                            percent = 100;
                        }
                        else if (percent <= 0)
                        {
                            Error("0% frequency indicator detected. Why is this here?", reader);
                            return;
                        }

                        reader.Position++; // Skip past '%'

                        if ((char)reader.PeekChar() == '[') // Make sure this bitch is tight
                        {
                            reader.Position++; // Skip past '['
                            int closure = reader.Source.FindClosingSquareBracket(reader.Position);

                            if (closure < 0)
                            {
                                Error("Missing closing bracket in frequency indicator.", reader);
                                return;
                            }

                            if (rand.Next(0, 101) > percent)
                            {
                                reader.Position = closure;
                            }

                            continue;
                        }
                        else
                        {
                            reader.Position = oldPos; // Fall back to beginning of number if there is a false positive and it's just a number
                        }
                    }
                }
                #endregion

                #region Selectors
                if (c == '{') // Selector. Picks random item inside brackets. Example: {First/second/third/fourth/...}
                {
                    int end = reader.Source.FindClosingCurlyBracket(reader.Position);
                    if (end == -1)
                    {
                        Error("Incomplete curly brackets. Did you forget to close a selector?", reader);
                        return;
                    }
                    int[] startIndices = reader.Source.GetSelectorSubs(reader.Position);
                    if (startIndices.Length < 2)
                    {
                        Error("Selector is empty or only has one option.", reader);
                        return;
                    }
                    activeSelectors.Add(end + 1);
                    selectorUniformIDs.Add(currentUniformID);
                    if (currentUniformID > -1)
                    {
                        LongRandom uniRand = new LongRandom(uniformSeedSalt + currentUniformID);
                        reader.Position = startIndices[uniRand.Next(0, startIndices.Length)];
                    }
                    else
                    {
                        reader.Position = startIndices[rand.Next(0, startIndices.Length)];
                    }
                    currentUniformID = -1;
                }
                else if (c == '}')
                {
                    if (activeSelectors.Count == 0)
                    {
                        Error("Unexpected '}' found in pattern.", reader);
                        return;
                    }

                    activeSelectors.RemoveAt(activeSelectors.Count - 1);
                    selectorUniformIDs.RemoveAt(selectorUniformIDs.Count - 1);
                    continue;
                }
                else if (c == '/')
                {
                    if (activeSelectors.Count == 0)
                    {
                        Error("Unexpected '/' found in pattern.", reader);
                        return;
                    }
                    reader.Position = activeSelectors[activeSelectors.Count - 1];
                    activeSelectors.RemoveAt(activeSelectors.Count - 1);
                    selectorUniformIDs.RemoveAt(selectorUniformIDs.Count - 1);
                    continue;
                }
                else if (c == '*')
                {
                    int bracketIndex = reader.Source.IndexOf("{", reader.Position);
                    if (bracketIndex <= reader.Position)
                    {
                        Error("Uniform operator could not find a selector to associate with.", reader);
                        return;
                    }
                    string strUID = reader.ReadString(bracketIndex - reader.Position);
                    int uid;
                    if (!int.TryParse(strUID, out uid))
                    {
                        Error("Uniform ID was not a number.", reader);
                        return;
                    }
                    else if (uid < 0)
                    {
                        Error("Uniform ID's cannot be negative.", reader);
                        return;
                    }
                    currentUniformID = uid;
                    continue;
                }
                #endregion

                #region Repeaters
                if (c == '^')
                {
                    // iteration range
                    if (reader.PeekChar() != '[')
                    {
                        Error("Repeater iterations parameter did not have an opening bracket.", reader);
                        return;
                    }
                    reader.ReadChar(); // skip [
                    int rightRangeBracketIndex = reader.Source.FindClosingSquareBracket(reader.Position);
                    if (rightRangeBracketIndex < 0)
                    {
                        Error("Repeater iterations parameter did not have a closing bracket.", reader);
                        return;
                    }
                    string strRangeParameter = reader.ReadString(rightRangeBracketIndex - reader.Position).Trim();
                    reader.ReadChar(); // skip ]
                    int constantParam = 0;
                    int min = 0;
                    int max = 0;
                    if (!int.TryParse(strRangeParameter, out constantParam))
                    {
                        string[] parts = strRangeParameter.Split(new char[] { '-' });
                        if (parts.Length != 2)
                        {
                            Error("Repeater range parameter must be a pair of two numbers.", reader);
                            return;
                        }
                        if (!int.TryParse(parts[0], out min) || !int.TryParse(parts[1], out max))
                        {
                            Error("Repeater range parameter did not contain valid numbers.", reader);
                            return;
                        }
                        if (min > max || min == 0 || max == 0)
                        {
                            Error("Repeater range must be greater than zero, and max > min.", reader);
                            return;
                        }
                        constantParam = rand.Next(min, max);
                    }
                    // separator
                    if (reader.ReadChar() != '[')
                    {
                        Error("Repeater separator parameter did not have an opening bracket.", reader);
                        return;
                    }
                    int sepIndex = reader.Position;
                    int rightSepBracketIndex = reader.Source.FindClosingSquareBracket(reader.Position);
                    if (rightSepBracketIndex < 0)
                    {
                        Error("Repeater separator parameter did not have a closing bracket.", reader);
                    }
                    string strSepParameter = reader.ReadString(rightSepBracketIndex - reader.Position);
                    int sepEnd = reader.Position;
                    reader.ReadChar(); // skip ]

                    // content
                    if (reader.ReadChar() != '[')
                    {
                        Error("Repeater content parameter did not have an opening bracket.", reader);
                        return;
                    }
                    int rightContentBracketIndex = reader.Source.FindClosingSquareBracket(reader.Position);
                    if (rightSepBracketIndex < 0)
                    {
                        Error("Repeater content parameter did not have a closing bracket.", reader);
                    }
                    int pStart = reader.Position;

                    reader.ReadString(rightContentBracketIndex - reader.Position);

                    int pEnd = reader.Position;

                    repeaters.Add(new RepeaterInstance(pStart, pEnd, sepIndex, sepEnd, strSepParameter, constantParam));

                    reader.Position = pStart;
                }
                else if (c == ']' && repeaters.Count > 0) // End of repeater iteration?
                {
                    int last = repeaters.Count - 1;
                    RepeaterInstance rep = repeaters[last];
                    if (reader.Position - 1 != rep.ContentEndIndex && reader.Position - 1 != rep.SeparatorEndIndex)
                    {
                        continue;
                    }

                    if (rep.OnSeparator) // Currently writing separator?
                    {
                        rep.OnSeparator = false;
                        reader.Position = rep.ContentStartIndex;
                    }
                    else // Currently writing content?
                    {
                        if (repeaters[last].Elapse())
                        {
                            repeaters.RemoveAt(last); // Remove the last repeater if it's finished
                            continue;
                        }
                        else
                        {
                            rep.OnSeparator = true;
                            reader.Position = rep.SeparatorStartIndex; // Add separator if not
                        }
                    }
                }
                #endregion

                #region Flags
                else if (c == '$')
                {
                    int leftBracket = reader.Source.IndexOf("[", reader.Position);
                    if (leftBracket < 0)
                    {
                        Error("Missing '[' on flag call.", reader);
                        return;
                    }
                    string func = reader.ReadString(leftBracket - reader.Position).ToLower();
                    reader.ReadChar(); // skip [
                    if (func.Contains(' '))
                    {
                        Error("Invalid flag function.", reader);
                        return;
                    }
                    int rightBracket = reader.Source.FindClosingSquareBracket(reader.Position);
                    if (rightBracket < leftBracket)
                    {
                        Error("Missing ']' on flag call.", reader);
                        return;
                    }
                    string firstParam = reader.ReadString(rightBracket - reader.Position);
                    reader.ReadChar(); // skip ]
                    if (func == "set")
                    {
                        if (!vflags.Contains(firstParam))
                        {
                            vflags.Add(firstParam);
                        }
                        continue;
                    }
                    else if (func == "unset")
                    {
                        if (vflags.Contains(firstParam))
                        {
                            vflags.Remove(firstParam);
                        }
                        continue;
                    }
                    else if (func == "if")
                    {
                        if (reader.ReadChar() != '[')
                        {
                            Error("Missing '[' in IF body.", reader);
                            return;
                        }
                        int rightBodyBracket = reader.Source.FindClosingSquareBracket(reader.Position);
                        if (rightBodyBracket < 0)
                        {
                            Error("Missing ']' in IF body.", reader);
                            return;
                        }
                        if (!vflags.Contains(firstParam))
                        {
                            reader.Position = rightBodyBracket;
                        }
                        continue;
                    }
                    else if (func == "ifnot")
                    {
                        if (reader.ReadChar() != '[')
                        {
                            Error("Missing '[' in IF body.", reader);
                            return;
                        }
                        int rightBodyBracket = reader.Source.FindClosingSquareBracket(reader.Position);
                        if (rightBodyBracket < 0)
                        {
                            Error("Missing ']' in IF body.", reader);
                            return;
                        }
                        if (vflags.Contains(firstParam))
                        {
                            reader.Position = rightBodyBracket;
                        }
                        continue;
                    }
                    else if (func == "g_set")
                    {
                        if (!flags.Contains(firstParam))
                        {
                            flags.Add(firstParam);
                        }
                        continue;
                    }
                    else if (func == "g_unset")
                    {
                        if (flags.Contains(firstParam))
                        {
                            flags.Remove(firstParam);
                        }
                        continue;
                    }
                    else if (func == "g_if")
                    {
                        if (reader.ReadChar() != '[')
                        {
                            Error("Missing '[' in IF body.", reader);
                            return;
                        }
                        int rightBodyBracket = reader.Source.IndexOf("]", reader.Position);
                        if (rightBodyBracket < 0)
                        {
                            Error("Missing ']' in IF body.", reader);
                            return;
                        }
                        if (!flags.Contains(firstParam))
                        {
                            reader.Position = rightBodyBracket;
                        }
                        continue;
                    }
                    else if (func == "g_ifnot")
                    {
                        if (reader.ReadChar() != '[')
                        {
                            Error("Missing '[' in IF body.", reader);
                            return;
                        }
                        int rightBodyBracket = reader.Source.IndexOf("]", reader.Position);
                        if (rightBodyBracket < 0)
                        {
                            Error("Missing ']' in IF body.", reader);
                            return;
                        }
                        if (flags.Contains(firstParam))
                        {
                            reader.Position = rightBodyBracket;
                        }
                        continue;
                    }
                    else
                    {
                        Error("Unrecognized flag function.", reader);
                        return;
                    }
                }
                #endregion
                else if (c == '+') // Random word
                {
                    string lockID = "";
                    char symbol = reader.ReadChar();
                    if (symbol == ' ' || symbol == '+' || symbol == '#' || symbol == '*' || symbol == '~' || symbol == '|')
                    {
                        Warning("Enountered illegal symbol: '" + symbol.ToString() + "'", reader);
                        continue;
                    }
                    else if (symbol == '[') // Check if there is a class accessor. (For example: +[class]n)
                    {
                        int closure = reader.Source.IndexOf(']', reader.Position);
                        if (closure < 0)
                        {
                            Error("Incomplete brackets in class accessor.", reader);
                            return;
                        }
                        className = reader.ReadString(closure - reader.Position);
                        reader.Position++; // Skip past ']'
                        symbol = reader.ReadChar();
                    }
                    if (reader.PeekChar() == '[') // Check if there is a subtype accessor. (For example: +n[subtype] or +[class]n[subtype])
                    {
                        reader.Position++;
                        int closure = reader.Source.IndexOf(']', reader.Position);
                        if (closure < 0)
                        {
                            Error("Incomplete brackets in subtype accessor.", reader);
                            return;
                        }
                        subType = reader.ReadString(closure - reader.Position);
                        reader.Position++; // Skip past ']'
                    }
                    if (reader.PeekChar() == '<') // Check if there is a word lock accessor. (For example: +n<#> or +[class]n[subtype]<#>)
                    {
                        string lockKey = className + ":" + symbol.ToString();
                        if (!locks.ContainsKey(lockKey))
                        {
                            locks.Add(lockKey, new Dictionary<string, int>());
                        }
                        reader.Position++;
                        int closure = reader.Source.IndexOf('>', reader.Position);
                        if (closure < 0)
                        {
                            Error("Incomplete brackets in word lock accessor.", reader);
                            return;
                        }
                        lockID = reader.ReadString(closure - reader.Position);
                        if (lockID == "")
                        {
                            Error("Empty word lock ID.", reader);
                            return;
                        }
                        if (!locks[lockKey].ContainsKey(lockID) && wordBank.ContainsKey(symbol)) // add a new word lock if a new ID is found --- this allows reuse of the word!
                        {
                            locks[lockKey].Add(lockID, wordBank[symbol].GetRandomIndex(rand, className));
                        }
                        reader.Position++; // Skip past '>'
                    }

                    if (!wordBank.ContainsKey(symbol)) // Make sure the symbol is registered
                    {
                        Warning("Word symbol not found: '" + symbol.ToString() + "'", reader);
                    }
                    else if (lockID != "")
                    {
                        buffer = wordBank[symbol].GetWordByIndex(locks[className + ":" + symbol.ToString()][lockID], subType, currentFormat);
                    }
                    else
                    {
                        if (className.Contains(","))
                        {
                            string[] mcNames = className.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                            if (mcNames.Length < 2)
                            {
                                Error("A multi-class expression must include more than one class name in its parameters.", reader);
                                return;
                            }
                            for (int i = 0; i < mcNames.Length; i++)
                            {
                                mcNames[i] = mcNames[i].Trim(); // this is to get rid of spaces between the class names
                            }
                            for (int i = 0; i < mcNames.Length; i++)
                            {
                                if (!ClassExists(symbol, mcNames[i]))
                                {
                                    Error("Bad multiclass", reader);
                                    return;
                                }
                            }
                            buffer = wordBank[symbol].GetRandomWordMultiClass(rand, subType, currentFormat, mcNames);
                        }
                        else if (!ClassExists(symbol, className))
                        {
                            Warning("Class not found: " + symbol.ToString() + " -> " + className, reader);
                        }
                        else
                        {
                            int index = wordBank[symbol].GetRandomIndex(rand, className);
                            buffer = wordBank[symbol].GetWordByIndex(index, subType, currentFormat);
                            if (graph != null && symbol == 'n')
                            {
                                graph.Add(wordBank[symbol].GetWordByIndex(index, "", WordFormat.None));
                            }
                        }
                    }
                    buffer = buffer.Capitalize(currentFormat);
                    if (anIndex > -1 && buffer.StartsWithVowel())
                    {
                        if (anFormat == WordFormat.AllCaps)
                        {
                            stream.Insert(anIndex, "N");
                        }
                        else
                        {
                            stream.Insert(anIndex, "n");
                        }
                    }

                    anIndex = -1;
                    anFormat = WordFormat.None;
                }
                else if (c == '|' || c == '\n') // Line break
                {
                    buffer = "\r\n";
                }
                else if (c == '~') // Capitalize
                {
                    if (reader.PeekChar() == '~')
                    {
                        reader.ReadChar();
                        currentFormat = WordFormat.Capitalized;
                    }
                    else if (currentFormat == WordFormat.Proper)
                    {
                        currentFormat = WordFormat.None;
                    }
                    else
                    {
                        currentFormat = WordFormat.Proper;
                    }
                }
                else if (c == '@') // Capslock
                {
                    if (currentFormat == WordFormat.AllCaps)
                    {
                        currentFormat = WordFormat.None;
                    }
                    else
                    {
                        currentFormat = WordFormat.AllCaps;
                    }
                }
                else if (c == '#') // Random number
                {
                    if (reader.PeekChar() == '[')
                    {
                        reader.Position++;

                        int closure = reader.Source.IndexOf(']', reader.Position);
                        if (closure < 0)
                        {
                            Error("Incomplete parenthases in random number range.", reader);
                            return;
                        }

                        string rangeStr = reader.ReadString(closure - reader.Position);
                        reader.Position++; // Skip past ']'

                        string[] rangeParts = rangeStr.Split('-');

                        if (rangeParts.Length != 2)
                        {
                            Error("Invalid number of range elements for random number. Got " + rangeParts.Length + ", need 2.", reader);
                            return;
                        }

                        int min;
                        int max;

                        if (!int.TryParse(rangeParts[0], out min))
                        {
                            Error("Invalid minimum value for random number.", reader);
                            return;
                        }

                        if (!int.TryParse(rangeParts[1], out max))
                        {
                            Error("Invalid maximum value for random number.", reader);
                            return;
                        }

                        buffer = rand.Next(min, max).ToString();
                    }
                }
                else if (c != '{' && c != '}' && c != '[' && c != ']' && c != '<' && c != '>') // Covers all other characters except brackets
                {
                    if (prev == ' ' && c == 'a' && !char.IsLetterOrDigit((char)reader.PeekChar())) // YES! YES!
                    {
                        anIndex = stream.Length + 1;
                        anFormat = currentFormat;
                    }
                    if (currentFormat == WordFormat.AllCaps || (currentFormat == WordFormat.Proper && !Char.IsLetterOrDigit(prev) && prev.PermitsCap()))
                    {
                        buffer = c.ToString().ToUpper();
                    }
                    else if (currentFormat == WordFormat.Capitalized)
                    {
                        buffer = c.ToString().ToUpper();
                        currentFormat = WordFormat.None;
                    }
                    else
                    {
                        buffer = c.ToString();
                    }
                }
                stream.Append(buffer);
                buffer = ""; // Fixes the word repitition bug when terminating Proper formatting in a pattern
            }
        }
Example #6
0
 private void ChangeWeights(LongRandom rand, int distSelect)
 {
     foreach (KeyValuePair<char, WordList> kvp in wordBank)
     {
         kvp.Value.RandomizeDistWeights(rand, distSelect);
     }
 }
Example #7
0
        public Story GenerateStoryObject(string seed, int chapterCount, int chapterLength, int weightDistSelect, int weightChangeOption)
        {
            flags.Clear();
            graph = new Histograph();
            LongRandom rngBase = new LongRandom(seed);
            rand = new LongRandom(seed);
            ChangeWeights(rand, weightDistSelect);
            AssignGlobals(rand);

            string title = GenerateFrom(patternBank["T"].GetPattern(rand));
            string author = GenerateFrom(patternBank["B"].GetPattern(rand));

            List<KeyValuePair<string, string>> chapters = new List<KeyValuePair<string, string>>();

            for (int i = 0; i < chapterCount; i++)
            {
                rand = new LongRandom(rngBase.Next());
                string chapterTitle = GenerateFrom(patternBank["C"].GetPattern(rand));
                int paragraphs = rand.Next(3 + 4 * chapterLength, 8 + 4 * chapterLength);
                StringBuilder builder = new StringBuilder();

                for (int j = 0; j < paragraphs; j++)
                {
                    if (i == 0 && j == 0)
                    {
                        GenerateFromOutline(builder, oIntros);
                        builder.AppendLine("\r\n");
                    }
                    else if (i == chapterCount - 1 && j == paragraphs - 1)
                    {
                        GenerateFromOutline(builder, oEndings);
                    }
                    else
                    {
                        GenerateFromOutline(builder, oBodies);
                        builder.AppendLine("\r\n");
                    }
                    if (weightChangeOption == 2)
                    {
                        ChangeWeights(rand, weightDistSelect);
                    }
                }
                if (weightChangeOption == 1)
                {
                    ChangeWeights(rand, weightDistSelect);
                }
                chapters.Add(new KeyValuePair<string, string>(chapterTitle, builder.ToString()));
            }
            return new Story(title, author, seed, chapters, graph);
        }
Example #8
0
        public void GenerateStory(StringBuilder stream, string seed, int chapters, bool includeSeed, bool romanChapterNumbers, int chapterLengthSelect, int weightDistSelect, int weightChangeOption, ref string storyTitle)
        {
            flags.Clear();
            // Check for required pattern types
            CheckPatternType("T"); // Story title
            CheckPatternType("B"); // Author full name
            CheckPatternType("C"); // Chapter name

            LongRandom rngBase = new LongRandom(seed);

            rand = new LongRandom(seed);

            ChangeWeights(rand, weightDistSelect);
            AssignGlobals(rand);

            if (storyTitle != null)
            {
                StringBuilder title = new StringBuilder();

                GenerateFromPattern(title, patternBank["T"]);
                storyTitle = title.ToString();
                stream.Append(title.ToString());
            }
            else
            {
                GenerateFromPattern(stream, patternBank["T"]);
            }

            stream.Append("\r\nBy ");
            GenerateFromPattern(stream, patternBank["B"]);
            stream.AppendLine();

            if (includeSeed)
            {
                stream.Append("(Seed: " + seed + ")");
                stream.AppendLine();
            }

            stream.AppendLine("---");

            for (int i = 0; i < chapters; i++)
            {
                rand = new LongRandom(rngBase.Next());
                string chapNum = romanChapterNumbers ? (i + 1).ToRoman() : (i + 1).ToString();

                stream.Append("\r\n\r\nCHAPTER " + chapNum + ": "); // chapter number
                GenerateFromPattern(stream, patternBank["C"]); // chapter name
                stream.AppendLine("\r\n");

                int paragraphs = rand.Next(3 + 4 * chapterLengthSelect, 8 + 4 * chapterLengthSelect);

                for (int j = 0; j < paragraphs; j++)
                {
                    if (i == 0 && j == 0)
                    {
                        GenerateFromOutline(stream, oIntros);
                        stream.AppendLine("\r\n");
                    }
                    else if (i == chapters - 1 && j == paragraphs - 1)
                    {
                        GenerateFromOutline(stream, oEndings);
                    }
                    else
                    {
                        GenerateFromOutline(stream, oBodies);
                        stream.AppendLine("\r\n");
                    }
                    if (weightChangeOption == 2)
                    {
                        ChangeWeights(rand, weightDistSelect);
                    }
                }
                if (weightChangeOption == 1)
                {
                    ChangeWeights(rand, weightDistSelect);
                }
            }
        }
Example #9
0
 public void AssignGlobals(LongRandom rand)
 {
     foreach (KeyValuePair<string, string> entry in globalBank)
     {
         StringBuilder sb = new StringBuilder();
         GenerateFromPattern(sb, entry.Value);
         globalValues[entry.Key] = sb.ToString();
     }
 }
Example #10
0
 public string GetPattern(LongRandom r)
 {
     return this.Patterns[r.Next(0, this.Patterns.Length)];
 }
Example #11
0
 public string GetRandomWordMultiClass(LongRandom rand, string subtype, WordFormat format, params string[] classNames)
 {
     int subIndex = LookForSubtype(subtype);
     if (subIndex == -1)
     {
         return Error("SubtypeNotFound->" + subtype);
     }
     for (int i = 0; i < classNames.Length; i++)
     {
         if (!this.Classes.ContainsKey(classNames[i]))
         {
             return Error("ClassNotFound->" + classNames[i]);
         }
     }
     List<int> mcList = GetMultiClassList(classNames);
     if (mcList.Count == 0)
     {
         return Error("EmptyMultiClass");
     }
     int index = PickByWeight(mcList, rand);
     return Format(Words[mcList[index]][subIndex], format);
 }
Example #12
0
 private int PickByWeight(string className, LongRandom rand)
 {
     int total = TotalWeights(className);
     int randomNumber = rand.Next(0, total);
     int selectedIndex = 0;
     if (className == "") // This will go through all the words
     {
         for (int i = 0; i < this.Weights.Length; i++)
         {
             if (randomNumber < this.Weights[i] + this.DistWeights[i])
             {
                 selectedIndex = i;
                 break;
             }
             randomNumber -= this.Weights[i] + this.DistWeights[i];
         }
     }
     else
     {
         List<int> c = this.Classes[className];
         int count = c.Count;
         for (int i = 0; i < count; i++)
         {
             if (randomNumber < this.Weights[c[i]] + this.DistWeights[c[i]])
             {
                 selectedIndex = i;
                 break;
             }
             randomNumber -= this.Weights[c[i]] + this.DistWeights[c[i]];
         }
     }
     return selectedIndex;
 }
Example #13
0
 private int PickByWeight(List<int> items, LongRandom rand)
 {
     int total = TotalWeights(items);
     int randomNumber = rand.Next(0, total);
     int selectedIndex = 0;
     int count = items.Count;
     for (int i = 0; i < count; i++)
     {
         if (randomNumber < this.Weights[items[i]] + this.DistWeights[items[i]])
         {
             selectedIndex = i;
             break;
         }
         randomNumber -= this.Weights[items[i]] + this.DistWeights[items[i]];
     }
     return selectedIndex;
 }
Example #14
0
 public void RandomizeDistWeights(LongRandom rand, int factor)
 {
     for (int i = 0; i < this.DistWeights.Length; i++)
     {
         if (rand.Next(0, factor * 3 + 1) == 0)
         {
             this.DistWeights[i] = rand.Next(1, 20) * factor;
         }
         else
         {
             this.DistWeights[i] = 0;
         }
     }
 }
        // 300x450
        public static Bitmap CreateCover(Story story, int resultTableLength, int itemCount)
        {
            try
            {
                var google = new GimageSearchClient(@"http://google.com");
                LongRandom rand = new LongRandom(story.Seed);
                Image imgMain = new Bitmap(300, 450);
                List<string> items = story.Histograph.GetMostFrequent(itemCount);

                using (Graphics g = Graphics.FromImage(imgMain))
                {
                    Color bg = Color.FromArgb(rand.Next(0, 256), rand.Next(0, 256), rand.Next(0, 256));
                    g.Clear(bg);

                    string typeFace = fontList[rand.Next(0, fontList.Length)];
                    StringFormat sf = new StringFormat();
                    sf.Alignment = StringAlignment.Center;
                    sf.LineAlignment = StringAlignment.Center;
                    Font titleFont = new Font(typeFace, 24F, FontStyle.Regular);
                    Font authorFont = new Font(typeFace, 14F, FontStyle.Regular);
                    SizeF titleSize = g.MeasureString(story.Title, titleFont, 268);
                    SizeF authorSize = g.MeasureString(story.Author, authorFont);
                    SolidBrush titleBrush = new SolidBrush(bg.GetBrightness() > 0.5 ? Color.Black : Color.White);
                    Rectangle titleBorder = new Rectangle(8, 8, 284, (int)titleSize.Height + 8);
                    RectangleF authorRect = new RectangleF(0, 442 - authorSize.Height, 300, authorSize.Height);
                    Rectangle pictureRect = new Rectangle(titleBorder.Left, titleBorder.Bottom + 8, titleBorder.Width, (int)authorRect.Top - titleBorder.Bottom - 16);

                    g.DrawString(story.Title, titleFont, titleBrush, new RectangleF(16, 16, 268, titleSize.Height), sf);
                    g.DrawRectangle(new Pen(titleBrush, 3), titleBorder);
                    g.DrawString(story.Author, authorFont, titleBrush, authorRect, sf);

                    // Draw illustration

                    g.Clip = new Region(pictureRect);

                    var bgResults = google.Search(story.Title, resultTableLength, SafeLevel.Off, ImageSize.Large, Colorization.All, ImageColor.All, ImageType.All, ImageFileType.All, "");
                    if (bgResults.Count > 0)
                    {
                        Bitmap background = (Bitmap)DownloadImageFromURL(bgResults[rand.Next(0, bgResults.Count)].Url, false);
                        if (background != null)
                        {
                            g.DrawImage(background, pictureRect);
                            background.Dispose();
                        }
                    }
                    else
                    {
                        g.Clear(Color.FromArgb(255, rand.Next(0, 256), rand.Next(0, 256), rand.Next(0, 256)));
                    }

                    foreach (string thing in items)
                    {
                        var imgResults = google.Search(thing, resultTableLength, SafeLevel.Off, ImageSize.All, Colorization.All, ImageColor.All, ImageType.All, ImageFileType.All, "");
                        Bitmap item = (Bitmap)DownloadImageFromURL(imgResults[rand.Next(0, imgResults.Count)].TbImage.Url, true);

                        int x = rand.Next(0, pictureRect.Width) + pictureRect.Left;
                        int y = rand.Next(0, pictureRect.Height) + pictureRect.Top;
                        int width = rand.Next(32, pictureRect.Width);
                        int height = rand.Next(32, pictureRect.Height);

                        g.TranslateTransform(x, y);
                        g.RotateTransform(rand.Next(0, 360));
                        g.ResetTransform();

                        g.DrawImage(item, new Rectangle(0, 0, width, height));
                        item.Dispose();
                    }
                    g.DrawRectangle(new Pen(titleBrush, 3), pictureRect);
                }
                return (Bitmap)imgMain;
            }
            catch
            {
                return null;
            }
        }