using System;

using System.Diagnostics;

using System.Drawing;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Room Generator");

        Random rnd = new Random(777);       

        /*

        for (int i=0; i<50; i++)

        {

            Console.WriteLine(rnd.Next(0, 10));

        }

        */

        generateTree(7777);

​

    }

    public static void generateTree(int seed)

    {

        const int MAX_LEAF_SIZE = 20;

        List<Leaf> leaves = new List<Leaf>();

        // Create root

        Leaf root = new Leaf(0,0,40,20, seed);

        leaves.Add(root);

        Random rnd = new Random(seed+777);

        // Loop through leaves

        while (leaves.Count<30)

        {

            int splitIdx = rnd.Next(leaves.Count);

            Leaf toSplit = leaves[splitIdx];

            if( toSplit.split() ) { //attempt to split

                leaves.Add( toSplit.leftChild );

                leaves.Add( toSplit.rightChild );

            }

        }

        root.generateRoom();

        printDungeons(leaves);

    }

    public static void printDungeons(List<Leaf> leaves) {

        char[][] lines = new char[40][];

        for( int i = 0; i < 40; i++ ) 

        {

            lines[i] = new char[20];

            for( int j = 0; j < 20; j++ )

                lines[i][j] =  '█';

        }

        int dungeonCount = -1;

        foreach( Leaf r in leaves ) 

        {

            Rectangle d = r.room;

            dungeonCount++;

            for( int i = 0; i < d.Height; i++ ) 

            {

                for( int j = 0; j < d.Width; j++ )

​

                    lines[ d.X + i ][ d.Y+ j ] = ' ';

            }

        }

        for( int j = 0; j < 20; j++ ) 

        {

            for( int i = 0; i < 40; i++ ) 

            {

                /*

                if( lines[ i ][ j ] == -1 )

                    System.out.print( '.');

                else

                    System.out.print( lines[ i ][ j ] );

                */

                Console.Write(lines[i][j]);

            }

            Console.Write("\n");

        }

    }

}

​

​

public class Leaf

{

    const int MIN_SIZE = 4;

    public int x, y, width, height;

    public Leaf leftChild, rightChild;

    public Rectangle room;

    public List<Rectangle> halls = new List<Rectangle>();

    private Random rnd;

​

    // Initializer

    public Leaf(int inX, int inY, int inWidth, int inHeight, int seed = 0)

    {

        x = inX;

        y = inY;

        width = inWidth;

        height = inHeight;

        //Console.WriteLine("seed="+seed);

        rnd = new Random(seed);

    }

    // Splitter

    public bool split()

    {

        // Begin splitting the leaf into two children

        if (leftChild != null || rightChild != null)

            return false; // Bail out if it is alread splitted.

        // Determine direction of split

        // if the width is >25% larger than height, we split vertically

        // if the height is >25% larger than the width, we split horizontally

        // otherwise we split randomly

        bool isSplitX = rnd.Next(2)==1;

        if (width > height && height / width >= 0.05)

            isSplitX = false;

        else if (height > width && width / height >= 0.05)

            isSplitX = true;

        // Determine max possible size to split

        int max = (isSplitX?height:width) - MIN_SIZE;

        if (max <= MIN_SIZE)

            return false; // This dimension is too small to split

        int splitPos = rnd.Next(MIN_SIZE, max);

        //Console.WriteLine(splitPos);

        if (isSplitX)

        {

            leftChild = new Leaf(x, y, width, splitPos, rnd.Next(111));

            rightChild = new Leaf(x, y + splitPos, width, height - splitPos, rnd.Next(222));

        }

        else

        {

            leftChild = new Leaf(x, y, splitPos, height, rnd.Next(333));

            rightChild = new Leaf(x + splitPos, y, width - splitPos, height, rnd.Next(444));

        }

        return true; // We have made this far

    }

    // Generate Dungeon

    public void generateRoom()

    {

        if (leftChild != null)  //if current are has child areas, propagate the call

        {

            leftChild.generateRoom();

            rightChild.generateRoom();

        }

        else // if leaf node, create a dungeon within the minimum size constraints

        {

            /*

            int dungeonTop = (height - MIN_SIZE <= 0) ? 0 : rnd.Next( height - MIN_SIZE);

            int dungeonLeft =  (width - MIN_SIZE <= 0) ? 0 : rnd.Next( width - MIN_SIZE);

            int dungeonHeight = Math.Max(rnd.Next( height - dungeonTop ), MIN_SIZE );;

            int dungeonWidth = Math.Max(rnd.Next( width - dungeonLeft ), MIN_SIZE );;

            room = new Rectangle( x+dungeonLeft, y + dungeonTop, dungeonHeight, dungeonWidth);

            */

            int dungeonTop = 0;

            int dungeonLeft =  0;

            int dungeonHeight = Math.Max(height-1, MIN_SIZE );;

            int dungeonWidth = Math.Max(width-1, MIN_SIZE );;

            room = new Rectangle( x+dungeonLeft, y + dungeonTop, dungeonHeight, dungeonWidth);

​

        }

    }

}