using System;

using System.Collections.Generic;

​

public class RNG

{

    public string Seed { get; set; }

    private int sLength;

    public string CharSpace { get; set; }

    private int csLength;

    private const int depth = 4;

    private int cyclesHorz = 1;

    private int cyclesVert = 1;

    public RNG(string seed, string charSpace)

    {

        Seed = seed;

        sLength = Seed.Length;

        CharSpace = charSpace;

        csLength = CharSpace.Length;

        cyclesHorz = Spit(sLength);

        cyclesVert = Spit(csLength);

    }

    public int Spit(int range)

    {

        int denominator = (int)(Math.Pow(csLength, depth));

        int numerator = 0;

        for(int xFloop = 0; xFloop < depth; xFloop++)

        {

            for(int yFloop = 0; yFloop < csLength; yFloop++)

            {

                if(Seed[xFloop].Equals(CharSpace[yFloop]))

                {

                    numerator = numerator + (yFloop*((int)(Math.Pow(csLength, xFloop))));

                    break;

                }

            }

        }

        int answer = ((range*numerator)/denominator);

        //Console.WriteLine(range + " * " + numerator + " / " + denominator + " = " + answer);

        Swish();

        return answer;

    }

    public void HorizontalShift(int shift)

    {

        string front = Seed.Substring(0, shift);

        string back = Seed.Substring(shift, Seed.Length - shift);

        Seed = back + front;

    }

    public void HorizontalShift() { HorizontalShift(1); }

    public void VerticalShift(int shift)

    {

        string temp = "";

        for(int xFloop = 0; xFloop < sLength; xFloop++)

        {

            for(int yFloop = 0; yFloop < csLength; yFloop++)

            {

                if(Seed[xFloop].Equals(CharSpace[yFloop]))

                {

                    temp = temp + CharSpace[(yFloop + shift) % csLength];

                    break;

                }

            }

        }

        Seed = temp;

    }

    public void VerticalShift() { VerticalShift(1); }

    public void Difference()

    {

        string temp = "";

        int beginIndex = 0;

        for(int floop = 0; floop < csLength; floop++)

        {

            if(Seed[0].Equals(CharSpace[floop]))

            {

                beginIndex = floop;

                break;

            }

        }

        for(int xFloop = 1; xFloop <= sLength; xFloop++)

        {

            for(int yFloop = 0; yFloop < csLength; yFloop++)

            {

                if(Seed[xFloop % sLength].Equals(CharSpace[yFloop]))

                {

                    temp = temp + CharSpace[(beginIndex + yFloop) % csLength];

                    beginIndex = yFloop;

                    break;

                }

            }

        }

        Seed = temp;

    }

    public void Difference(int cycles)

    {

        for(int floop = 0; floop < cycles; floop++)

            Difference();

    }

    public void Swish()

    {

        // simple way to do it and still is pretty random, you can do tons of combinations with different amounts of iterations

        HorizontalShift(cyclesHorz);

        VerticalShift(cyclesVert);

        Difference();

        cyclesHorz++;

        if(cyclesHorz == sLength)

            cyclesHorz = 1;

        cyclesVert++;

        if(cyclesVert == csLength)

            cyclesVert = 1;

        //Console.WriteLine(Seed);

    }

    public void Swish(int cycles)

    {

        for(int floop = 0; floop < cycles; floop++)

            Swish();

    }

}

​

public class Dungeon

{

    public RNG rng;

    public char[,] space;

    public int xSize = 1;

    public int ySize = 1;

    public int numRooms;

    public Dungeon(RNG r, int x, int y, int nr)

    {

        rng = r;

        xSize = x;

        ySize = y;

        numRooms = nr;

        space = new char[y, x];

        for(int yFloop = 0; yFloop < ySize; yFloop++)

        {

            for(int xFloop = 0; xFloop < xSize; xFloop++)

                space[yFloop,xFloop] = '.';

        }

        for(int floop = 0; floop < numRooms; floop++)

            AddRoom(Convert.ToChar(65 + floop));

    }

    public void Display()

    {

        for(int yFloop = 0; yFloop < ySize; yFloop++)

        {

            for(int xFloop = 0; xFloop < xSize; xFloop++)

                Console.Write(space[yFloop,xFloop]);

            Console.WriteLine();

        }

    }

    private void AddRoom(char label)

    {

        bool keepGoing = true;

        do

        {

            int x = rng.Spit(xSize);

            int y = rng.Spit(ySize);

            if(space[y,x] == '.')

            {

                space[y,x] = label;

                keepGoing = false;  

            }

        }while(keepGoing);

    }

}

​

public class Program

{

    public static void Main()

    {

        RNG rng = new RNG("OCARINA OF TIME", "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ");

        Dungeon dungeon = new Dungeon(rng,32,16,10);

        dungeon.Display();

        List<char> path = new List<char>();

        for(int floop = 0; floop < 25; floop++)

        {

            Console.Write(Convert.ToChar(65 + rng.Spit(12)));

        }

    }

}