DungeonGenerator/src/dungeon/Dungeon.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package dungeon;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import main.Counter;
import main.Dice;
import org.jgraph.graph.DefaultEdge;
import org.jgrapht.UndirectedGraph;
import org.jgrapht.graph.SimpleGraph;

/**
 *
 * @author MrMcX
 */
public class Dungeon {
    private final List<Room> rooms;
    private final LinkedList<Room> toGenerate;
    private final Counter counter;
    
    public Dungeon(int size, Type type, Mode mode){
        rooms = new ArrayList<>();
        toGenerate = new LinkedList<>();
        counter = new Counter();
        generate(size, type, mode);
    }
    
    private void generate(int size, Type type, Mode mode){
        toGenerate.add(Room.RandomRoom(true, Exit.Start(), counter, type));
        while(!toGenerate.isEmpty() && rooms.size() < size){
            Room next;
            switch(mode){
                case STRAIGHT:
                    next = toGenerate.getLast();
                    break;
                case BRANCHED:
                    next = toGenerate.getFirst();
                    break;
                case RANDOM:
                    next = toGenerate.get(Dice.Roll(toGenerate.size(), 1)-1);
                    break;
                default:
                    next = toGenerate.getFirst();
                    break;
            }
            next.generate(counter, type).stream().forEach((r) -> {
                toGenerate.add(r);
            });
            toGenerate.remove(next);
            rooms.add(next);            
        }
    }
    
    @Override
    public String toString(){
        return rooms.stream().map((r) -> r.toLongString() + "\n").reduce("", String::concat);
    }
    
    public UndirectedGraph toGraph(){
        UndirectedGraph g = new SimpleGraph(DefaultEdge.class);        
        rooms.stream().forEach((r) -> {
            g.addVertex(r);
        });
        rooms.stream().forEach((r) -> {
            for(Exit e : r.exits){
                if(e.isStart || e.room.number == 0 || g.containsEdge(r, e.room)){
                    continue;
                }
                g.addEdge(r, e.room, e);
            }
        });
        return g;
    }
    
    public static boolean Natural(Type n){
        return (n == Type.NATURAL || n == Type.EXP_NATURAL);
    }
    
    public static enum Mode{
        STRAIGHT,
        BRANCHED,
        RANDOM,
    }
    
    public static enum Type{
        NATURAL,
        ARTIFICIAL,
        EXP_NATURAL,
        EXP_ARTIFICIAL
    }
}