Beispiel #1
0
    // Use this for initialization
    void Start()
    {
        mGenerator = new DungeonGenerator <Cell>();
        mBuilder   = mGenerator.GenerateA()
                     .MediumDungeon()
                     .ABitRandom()
                     .SomewhatSparse()
                     .WithMediumChanceToRemoveDeadEnds()
                     .WithMediumSizeRooms()
                     .WithLargeNumberOfRooms();
        mPrefabByWalls[EAST]                        = E;
        mPrefabByWalls[EAST | WEST]                 = EW;
        mPrefabByWalls[NORTH]                       = N;
        mPrefabByWalls[NORTH | EAST]                = NE;
        mPrefabByWalls[NORTH | EAST | WEST]         = NEW;
        mPrefabByWalls[NORTH | EAST | SOUTH]        = NES;
        mPrefabByWalls[NORTH | EAST | WEST | SOUTH] = NEWS;
        mPrefabByWalls[NORTH | SOUTH]               = NS;
        mPrefabByWalls[NORTH | SOUTH | WEST]        = NSW;
        mPrefabByWalls[NORTH | WEST]                = NW;
        mPrefabByWalls[0]                   = OPEN;
        mPrefabByWalls[SOUTH]               = S;
        mPrefabByWalls[SOUTH | EAST]        = SE;
        mPrefabByWalls[SOUTH | EAST | WEST] = SEW;
        mPrefabByWalls[SOUTH | WEST]        = SW;
        mPrefabByWalls[WEST]                = W;

        mCamHalfHeight   = Camera.main.orthographicSize;
        mCamHalfWidth    = Camera.main.aspect * mCamHalfHeight;
        mTopLeftPosition = new Vector3(-mCamHalfWidth + mMargin, mCamHalfHeight + mMargin, 0) + Camera.main.transform.position;
        Generate();
    }
Beispiel #2
0
 public void GenerateWithParameters(string parameters)
 {
     var parametersArr = JSON.Parse(parameters);
     mBuilder = mGenerator.GenerateA();
     for (int i = 0; i < parametersArr.Count; i++)
     {
         mBuilder = ParseParamToMethod(parametersArr[i].Value, mBuilder);
     }
     Generate();
 }
Beispiel #3
0
    public void GenerateWithParameters(string parameters)
    {
        var parametersArr = JSON.Parse(parameters);

        mBuilder = mGenerator.GenerateA();
        for (int i = 0; i < parametersArr.Count; i++)
        {
            mBuilder = ParseParamToMethod(parametersArr[i].Value, mBuilder);
        }
        Generate();
    }
Beispiel #4
0
        private void CallRecursivelyWithFixedDimensions(DungeonConfigurationGenerator <Cell> defaultBuilder,
                                                        List <KeyValuePair <string, Func <DungeonConfigurationGenerator <Cell>, DungeonConfigurationGenerator <Cell> > > > fixedDimensions,
                                                        List <Dictionary <string, Func <DungeonConfigurationGenerator <Cell>, DungeonConfigurationGenerator <Cell> > > > restOfDimensions)
        {
            if (restOfDimensions.Count > 0)
            {
                foreach (var dimension in restOfDimensions[0])
                {
                    var newFixed = fixedDimensions.ToList();
                    newFixed.Add(dimension);
                    CallRecursivelyWithFixedDimensions(defaultBuilder, newFixed, restOfDimensions.Skip(1).ToList());
                }
                return;
            }

            TestWithFixedDimensions(defaultBuilder, fixedDimensions);
        }
Beispiel #5
0
        public void SinglePreProcessorTest()
        {
            var config = new DungeonConfigurationGenerator <Cell>(null)
                         .DungeonOfSize(500, 500)
                         .NotRandom()
                         .GetConfiguration();
            var mazeGenerator = new MazeGenerator <BinaryCell>();

            for (var i = 0; i < ITERATIONS; i++)
            {
                Console.Write("{0},", i);
                var map = new Map <BinaryCell>(config.Width / 2, config.Height / 2);
                mazeGenerator.ProcessMap(map, config, new Randomizer());
            }
            Console.WriteLine();
            //StaticTimer.WriteResults(ITERATIONS);
        }
Beispiel #6
0
        private void GenerateAndAssert(
            Func <DungeonConfigurationGenerator <Cell>, DungeonConfigurationGenerator <Cell> > method,
            Action <DungeonConfiguration> assertMethod)
        {
            DungeonConfiguration targetConfiguration = null;
            var fakeGenerator = A.Fake <DungeonGenerator <Cell> >();

            A.CallTo(() => fakeGenerator.Generate(null, null))
            .WithAnyArguments()
            .Invokes(callObject => targetConfiguration = callObject.Arguments[0] as DungeonConfiguration);

            var configGenerator = new DungeonConfigurationGenerator <Cell>(fakeGenerator);

            method(configGenerator).Now();

            assertMethod(targetConfiguration);
        }
Beispiel #7
0
        private void TestWithFixedDimensions(DungeonConfigurationGenerator <Cell> defaultBuilder,
                                             IEnumerable <KeyValuePair <string, Func <DungeonConfigurationGenerator <Cell>, DungeonConfigurationGenerator <Cell> > > > fixedDimensions)
        {
            var       maxRooms                   = 5;
            var       failedIterationCount       = 0;
            const int MAX_FAILED_ITERATION_COUNT = 3;
            var       kvps = fixedDimensions.ToList();

            defaultBuilder = kvps.Aggregate(defaultBuilder, (current, dimension) => dimension.Value(current));

            try
            {
                while (failedIterationCount < MAX_FAILED_ITERATION_COUNT)
                {
                    defaultBuilder = defaultBuilder.WithRoomCount(maxRooms);
                    var map = defaultBuilder.Now();
                    if (map.Rooms.Count == maxRooms)
                    {
                        maxRooms++;
                    }
                    else
                    {
                        failedIterationCount++;
                    }
                }
                var config            = defaultBuilder.GetConfiguration();
                var medianRoomHeight  = (config.MaxRoomHeight + config.MinRoomHeight) / 2f;
                var medianRoomWidth   = (config.MaxRoomWidth + config.MinRoomWidth) / 2f;
                var maxPotentialRooms = (int)(config.Width / medianRoomWidth) * (int)(config.Height / medianRoomHeight);
                var result            = (maxPotentialRooms * (1 - config.Sparseness));
                Console.WriteLine("{0},{1},{2},{3}, ratio: {4}", (config.Width * config.Height), config.Sparseness, maxRooms - 1,
                                  (maxPotentialRooms * (1 - config.Sparseness)),
                                  (maxRooms - 1) / result);
            }
            catch (Exception)
            {
                Console.WriteLine(String.Join(" ", kvps.Select(kvp => kvp.Key)) + ": failed on " + (maxRooms - 1));
            }
        }
Beispiel #8
0
    // Use this for initialization
    void Start()
    {
        mGenerator = new DungeonGenerator<Cell>();
        mBuilder = mGenerator.GenerateA()
            .MediumDungeon()
            .ABitRandom()
            .SomewhatSparse()
            .WithMediumChanceToRemoveDeadEnds()
            .WithMediumSizeRooms()
            .WithLargeNumberOfRooms();
        mPrefabByWalls[EAST] = E;
        mPrefabByWalls[EAST | WEST] = EW;
        mPrefabByWalls[NORTH] = N;
        mPrefabByWalls[NORTH | EAST] = NE;
        mPrefabByWalls[NORTH | EAST | WEST] = NEW;
        mPrefabByWalls[NORTH | EAST | SOUTH] = NES;
        mPrefabByWalls[NORTH | EAST | WEST | SOUTH] = NEWS;
        mPrefabByWalls[NORTH | SOUTH] = NS;
        mPrefabByWalls[NORTH | SOUTH | WEST] = NSW;
        mPrefabByWalls[NORTH | WEST] = NW;
        mPrefabByWalls[0] = OPEN;
        mPrefabByWalls[SOUTH] = S;
        mPrefabByWalls[SOUTH | EAST] = SE;
        mPrefabByWalls[SOUTH | EAST | WEST] = SEW;
        mPrefabByWalls[SOUTH | WEST] = SW;
        mPrefabByWalls[WEST] = W;

        mCamHalfHeight = Camera.main.orthographicSize;
        mCamHalfWidth = Camera.main.aspect * mCamHalfHeight;
        mTopLeftPosition = new Vector3(-mCamHalfWidth + mMargin, mCamHalfHeight + mMargin, 0) + Camera.main.transform.position;
        Generate();
    }
Beispiel #9
0
 private DungeonConfigurationGenerator<Cell> ParseParamToMethod(string methodName, DungeonConfigurationGenerator<Cell> builder)
 {
     switch (methodName)
     {
         //size
         case "TinyDungeon":
             return builder.TinyDungeon();
         case "SmallDungeon":
             return builder.SmallDungeon();
         case "MediumDungeon":
             return builder.MediumDungeon();
         case "LargeDungeon":
             return builder.LargeDungeon();
         case "HugeDungeon":
             return builder.HugeDungeon();
         //randomness
         case "NotRandom":
             return builder.NotRandom();
         case "ABitRandom":
             return builder.ABitRandom();
         case "SomewhatRandom":
             return builder.SomewhatRandom();
         case "VeryRandom":
             return builder.VeryRandom();
         //sparseness
         case "NotSparse":
             return builder.NotSparse();
         case "ABitSparse":
             return builder.ABitSparse();
         case "SomewhatSparse":
             return builder.SomewhatSparse();
         case "VerySparse":
             return builder.VerySparse();
         //deadends
         case "DontRemoveDeadEnds":
             return builder.DontRemoveDeadEnds();
         case "WithSmallChanceToRemoveDeadEnds":
             return builder.WithSmallChanceToRemoveDeadEnds();
         case "WithMediumChanceToRemoveDeadEnds":
             return builder.WithMediumChanceToRemoveDeadEnds();
         case "WithBigChanceToRemoveDeadEnds":
             return builder.WithBigChanceToRemoveDeadEnds();
         case "RemoveAllDeadEnds":
             return builder.RemoveAllDeadEnds();
         //room size
         case "WithSmallSizeRooms":
             return builder.WithSmallSizeRooms();
         case "WithMediumSizeRooms":
             return builder.WithMediumSizeRooms();
         case "WithLargeSizeRooms":
             return builder.WithLargeSizeRooms();
         //room count
         case "WithSmallNumberOfRooms":
             return builder.WithSmallNumberOfRooms();
         case "WithMediumNumberOfRooms":
             return builder.WithMediumNumberOfRooms();
         case "WithLargeNumberOfRooms":
             return builder.WithLargeNumberOfRooms();
     }
     return builder;
 }
        private void GenerateAndAssert(
            Func<DungeonConfigurationGenerator<Cell>, DungeonConfigurationGenerator<Cell>> method,
            Action<DungeonConfiguration> assertMethod)
        {
            DungeonConfiguration targetConfiguration = null;
            var fakeGenerator = A.Fake<DungeonGenerator<Cell>>();
            A.CallTo(() => fakeGenerator.Generate(null, null))
                .WithAnyArguments()
                .Invokes(callObject => targetConfiguration = callObject.Arguments[0] as DungeonConfiguration);

            var configGenerator = new DungeonConfigurationGenerator<Cell>(fakeGenerator);
            method(configGenerator).Now();

            assertMethod(targetConfiguration);
        }
Beispiel #11
0
    private DungeonConfigurationGenerator <Cell> ParseParamToMethod(string methodName, DungeonConfigurationGenerator <Cell> builder)
    {
        switch (methodName)
        {
        //size
        case "TinyDungeon":
            return(builder.TinyDungeon());

        case "SmallDungeon":
            return(builder.SmallDungeon());

        case "MediumDungeon":
            return(builder.MediumDungeon());

        case "LargeDungeon":
            return(builder.LargeDungeon());

        case "HugeDungeon":
            return(builder.HugeDungeon());

        //randomness
        case "NotRandom":
            return(builder.NotRandom());

        case "ABitRandom":
            return(builder.ABitRandom());

        case "SomewhatRandom":
            return(builder.SomewhatRandom());

        case "VeryRandom":
            return(builder.VeryRandom());

        //sparseness
        case "NotSparse":
            return(builder.NotSparse());

        case "ABitSparse":
            return(builder.ABitSparse());

        case "SomewhatSparse":
            return(builder.SomewhatSparse());

        case "VerySparse":
            return(builder.VerySparse());

        //deadends
        case "DontRemoveDeadEnds":
            return(builder.DontRemoveDeadEnds());

        case "WithSmallChanceToRemoveDeadEnds":
            return(builder.WithSmallChanceToRemoveDeadEnds());

        case "WithMediumChanceToRemoveDeadEnds":
            return(builder.WithMediumChanceToRemoveDeadEnds());

        case "WithBigChanceToRemoveDeadEnds":
            return(builder.WithBigChanceToRemoveDeadEnds());

        case "RemoveAllDeadEnds":
            return(builder.RemoveAllDeadEnds());

        //room size
        case "WithSmallSizeRooms":
            return(builder.WithSmallSizeRooms());

        case "WithMediumSizeRooms":
            return(builder.WithMediumSizeRooms());

        case "WithLargeSizeRooms":
            return(builder.WithLargeSizeRooms());

        //room count
        case "WithSmallNumberOfRooms":
            return(builder.WithSmallNumberOfRooms());

        case "WithMediumNumberOfRooms":
            return(builder.WithMediumNumberOfRooms());

        case "WithLargeNumberOfRooms":
            return(builder.WithLargeNumberOfRooms());
        }
        return(builder);
    }