Skins: |

NWN SCRIPTS

- Jump to comments -

Title

Random Dungeon Generator

Author

Blight

Submitted / Updated

01-07-2003 / 11-22-2006

Category

Area

Expansions

Works on all versions

View Code

/*************************************************************************
/     rd_gen_dungeon - a part of the Random Dungeon Generator by Blight
/
/     To use this script:
/       This script is used automatically where needed
/
/*************************************************************************/

void RunTunnel( float fX, float fY, int dX, int dY, int iLen)
// Sends a tunnel between two cells
// fX and fY are the starting position
// dX and dY determine the direction
// iLen is the length of the tunnel
{
    int i;
    vector vPosition;
    location lLocation;

    for(i = 0; i < iLen; i++)
    {
        vPosition = Vector(fX - 2.0 * dY, fY - 2.0 * dX);
        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_tunnel", 1);
        vPosition = Vector(fX + 2.0 * dY, fY + 2.0 * dX);
        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_tunnel", 1);
        fX += 2.0 * dX;
        fY += 2.0 * dY;
    }
}

void DropCages( location lPlace, int iCellSize )
// Creates the basic set of cages that is the building bloc of every dungeon
// These are the 'cells'
// lPlace is the bottom left of the location to put the cell
// iCellSize is the size of the cell
{
    int i, j;
    // numbers for basic trig conversions
    float fAngle, fMagnitude, fX, fY;
    // the vector that represents the cage's position
    vector vPosition;
    object oArea = GetAreaFromLocation(lPlace);

    // we need the vector
    vPosition = GetPositionFromLocation(lPlace);
    // actually, we need the X and Y parts of the vector
    fAngle = VectorToAngle(vPosition);
    fMagnitude = VectorMagnitude(vPosition);
    fX = fMagnitude * cos(fAngle) + 1.0;
    fY = fMagnitude * sin(fAngle) + 1.0;

    // place cages with dungeon_wall flag, so we know they are 'permanent'
    for (i = 0; i < iCellSize; i++)
    {
        if(i != iCellSize/2)
        {
            vPosition = Vector(fX, fY, 0.0);
            lPlace = Location(oArea, vPosition, 0.0);
            SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lPlace), "dungeon_wall", 1);
        }
        fX += 2.0;
    }
    fX -= 2.0 * iCellSize;
    fY += 2.0;

    for (i = 0; i < iCellSize - 1; i ++)
    {
        if(i != (iCellSize-2)/2)
        {
            vPosition = Vector(fX, fY, 0.0);
            lPlace = Location(oArea, vPosition, 0.0);
            SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lPlace), "dungeon_wall", 1);
        }
        fY += 2.0;
    }
}

void main()
{
    // Cell Size
    int iCellSize;
    // Length is the length of a cell, including extra walls
    // Offset is the length that also includes the tunnel
    float fLength, fOffset = 0.0;
    // width and height of the dungeon
    int iMaxX, iMaxY;
    // this is used for drawing openings in the sides
    int iHalfStep;
    // iX and iY track the current cell on the grid
    int iX, iY, i;
    float fX, fY;
    // the length of the tunnel connecting cells
    int iTunnelLen = 0;
    // enable if a second wall is to be drawn, otherwise the cells try to share
    int iDrawSecondEdge = 0;
    // variables used for tracking the creation of exits
    int iTargetExits = 0;
    int iActualExits = 0;
    int iExitChance;
    // if there was a path drawn to the right on the previous coll,
    // we need to draw a path on  the left on this one
    // it is set to one to allow for the only exit.
    int iPathFromLeft;
    // vector to form the location
    vector vPosition;
    // location to place the cell, or the cage
    location lLocation;
    object oTag;
    // object for cleanup when redrawing
    object oDestroy = GetFirstObjectInArea();
    object oFlags;

    // Get the tag with information on the dungeon
    oTag = GetNearestObjectByTag("random_maze", GetFirstObjectInArea(OBJECT_SELF));
    if (!GetIsObjectValid(oTag))
        oTag = GetFirstObjectInArea(OBJECT_SELF);

    iTargetExits = GetFortitudeSavingThrow(oTag);
    iMaxX = GetReflexSavingThrow(oTag);
    iMaxY = GetWillSavingThrow(oTag);

    if (iTargetExits > 0)
        iExitChance = (iTargetExits * 100) / ( 2 * (iMaxX + iMaxY) );
    else
        iExitChance = 0;

    oFlags = GetNearestObjectByTag("tunnel_flags", oTag);
    if(oFlags != OBJECT_INVALID)
    {
        iCellSize = GetFortitudeSavingThrow(oFlags) + 2;
        iTunnelLen = GetReflexSavingThrow(oFlags);
        fOffset += 2.0 * (iTunnelLen + 1);
        iDrawSecondEdge = 1;
    }
    else
    {
        iCellSize = 5;
    }


    fLength = 2.0 * iCellSize;
    fOffset += fLength;

    iHalfStep = FloatToInt(fLength) / 2;
    if (IntToFloat(iHalfStep)/2 == IntToFloat(iHalfStep/2))
        iHalfStep += 1;


    // before we draw new cells, delete all the old cages.
    while(oDestroy != OBJECT_INVALID)
    {
        // check if it's part of the dungeon
        if (GetLocalInt(oDestroy, "dungeon_wall") || GetLocalInt(oDestroy, "dungeon_tunnel") || GetLocalInt(oDestroy, "dungeon_block"))
            DestroyObject(oDestroy);
        oDestroy = GetNextObjectInArea();
    }

    iMaxX += 1;
    iMaxY += 1;

    // initialize the path_down_x vars
    // these tell us if there should be a path drawn at the bottom
    // (because a path was drawn at the top below)
    for(iX = 0; iX < iMaxX; iX++)
    {
        if (iActualExits < iTargetExits && d100() <= iExitChance)
        {
            SetLocalInt(OBJECT_SELF, "path_down_" + IntToString(iX), 1);
            iActualExits += 1;
        }
        else
            SetLocalInt(OBJECT_SELF, "path_down_" + IntToString(iX), 0);
    }
    if (iActualExits < iTargetExits && d100() <= iExitChance)
    {
        iPathFromLeft = 1;
        iActualExits += 1;
    }
    else
        iPathFromLeft = 0;

    // recalculate to help distribution
    if (iTargetExits > 0)
    {
        iExitChance = ((iTargetExits-iActualExits) * 100) / (iMaxX + 2*iMaxY);
    }

    for(iY = 1; iY < iMaxY; iY += 1)
    {
        for (iX = 1; iX < iMaxX; iX += 1)
        {
            vPosition = Vector(fOffset * iX, fOffset * iY, 0.0);
            lLocation = Location(OBJECT_SELF, vPosition, 0.0);
            DropCages(lLocation, iCellSize);
            if(iDrawSecondEdge > 0)
            {
                fX = fOffset * iX + fLength + 1;
                fY = fOffset * iY + 1;
                for (i = 0; i < iCellSize+1; i++)
                {
                    if (i != iCellSize / 2)
                    {
                        vPosition = Vector(fX, fY);
                        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_wall", 1);
                    }
                    fY += 2.0;
                }
                fX -= iCellSize * 2.0;
                fY -= 2.0;
                for (i = 0; i < iCellSize; i++)
                {
                    if (i != (iCellSize) / 2)
                    {
                        vPosition = Vector(fX, fY);
                        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_wall", 1);
                    }
                    fX += 2.0;
                }
            }

            // check on path_down_x var
            if(GetLocalInt(OBJECT_SELF, "path_down_" + IntToString(iX)) == 0)
            {
                // draw on bottom
                vPosition = Vector(fOffset * iX + iHalfStep, fOffset * iY + 1);
                lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
            }

            // check if the way to the left is already barred
            if(iPathFromLeft == 0)
            {
                // draw on left
                vPosition = Vector(fOffset * iX + 1, fOffset * iY + iHalfStep);
                lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
            }


            // at the end of each row, block the right side
            if (iX == iMaxX - 1)
            {
                fX = fOffset * iX + fLength + 1;
                fY = fOffset * iY + 1;
                for (i = 0; i < iCellSize+1; i++)
                {
                    if (i != iCellSize / 2)
                    {
                        vPosition = Vector(fX, fY);
                        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_wall", 1);
                    }
                    fY += 2.0;
                }
                // randomly create an exit to the right
                if (iActualExits < iTargetExits && d100() <= iExitChance)
                    iActualExits += 1;
                else
                {
                    vPosition = Vector(fOffset * iX + fLength + 1, fOffset * iY + iHalfStep);
                    lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                    SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
                }
                // randomly create an exit on the left on the next row
                if (iActualExits < iTargetExits && d100() <= iExitChance)
                {
                    iActualExits += 1;
                    iPathFromLeft = 1;
                }
                else
                {
                    iPathFromLeft = 0;
                }
            }
            // randomly block a path to the right
            else if(d100() <= GetCurrentHitPoints(oTag))
            {
                iPathFromLeft = 0;
                // draw on right
                if (iDrawSecondEdge)
                {
                    vPosition = Vector(fOffset * iX + fLength + 1, fOffset * iY + iHalfStep);
                    lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                    SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
                }
            }
            else
            {
                iPathFromLeft = 1;
                // draw the tunnel
                RunTunnel(fOffset * iX + fLength + 3, fOffset * iY + iHalfStep, 1, 0, iTunnelLen);
            }

            // this is the top row, block the top side
            if(iY == iMaxY - 1)
            {
                // draw on top
                fX = fOffset * iX + 1;
                fY = fOffset * iY + fLength + 1;
                for (i = 0; i < iCellSize; i++)
                {
                    if (i != (iCellSize) / 2)
                    {
                        vPosition = Vector(fX, fY);
                        lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                        SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_wall", 1);
                    }
                    fX += 2.0;
                }
                // randomly create an exit on the top
                if (iActualExits < iTargetExits && d100() <= iExitChance)
                    iActualExits += 1;
                else
                {
                    vPosition = Vector(fOffset * iX + iHalfStep, fOffset * iY + fLength + 1);
                    lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                    SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
                }
            }
            // randomly block a path up
            else if(d100() <= GetCurrentHitPoints(oTag))
            {
                SetLocalInt(OBJECT_SELF, "path_down_" + IntToString(iX), 0);
                // draw on top
                if (iDrawSecondEdge)
                {
                    vPosition = Vector(fOffset * iX + iHalfStep, fOffset * iY + fLength + 1);
                    lLocation = Location(OBJECT_SELF, vPosition, 0.0);
                    SetLocalInt(CreateObject(OBJECT_TYPE_PLACEABLE, "plc_animalcage", lLocation), "dungeon_block", 1);
                }
            }
            else
            {
                SetLocalInt(OBJECT_SELF, "path_down_" + IntToString(iX), 1);
                // draw the tunnel
                RunTunnel(fOffset * iX + iHalfStep, fOffset * iY + fLength + 3, 0, 1, iTunnelLen);
            }
        }
    }
    SetLocalInt(GetArea(oTag), "has_been_drawn", 1);
}

Select All Text | View Code in separate window

Format

Code Only

Type

Type - Other

Includes

None

Description

Use this script to generate randomly created dungeons in your modules. This is accomplished without any scripting on your part. All you need to do is place objects in your area, and add one script as that area's OnEnter event.

There are several ways to configure your dungeon. You can change the size or number of 'cells.' You can add narrow passages between the cells. You can even make the dungeon change its shape as the player tries to solve the maze.

This package is capable of handling multiple random dungeons, each in a different area. They can be configured differently, or the same.

I tried to test this fairly extensively in SP, and I kept MP in mind as I coded, but it is untested. Any feedback on bugs will be greatly appreciated, as well as new ideas for features to add in the next version.

See it in action on my demo module here.

Files

Name	Type	Size	Downloads
RandomDungeonGen.zipRandomDungeonGen.zip Submitted: 01-07-2003 / Last Updated: 01-07-2003	zip	8.33Kb	1340
--

SCORE OUT OF 10

9.58
5 votes
View Stats
Cast Your Vote!

PORTFOLIO

Add this entry to your portfolio so you can track it

Manage your existing portfolios or create a new one.

SCREENS

No Images

You Must Be Logged In to Participate.

Comments (11):

Posted by A Well-Known Swell Guy at 2007-09-09 08:28:53 Voted 10.00 on 09/09/07

OMG this is amazing, you have my thanks

Posted by DM_Castillo at 2007-04-29 07:39:51 Voted 10.00 on 04/29/07

Just what i needed to 0 ' ' ' Lands of nordock Primordia Nordock in RP

Posted by Nathan T at 2007-02-24 02:58:34 Voted 9.75 on 02/24/07

Brilliant, though the cages can get a bit tardy,but still. ur a mastermind to think up this one, keep going!

Posted by Persh at 2005-11-05 17:50:20 Voted 9.00 on 11/05/05

One word : Awesome.

Posted by Old_Scores_Transfered at 2004-02-20 10:29:18 Voted 8.00 on 02/20/04

This is a compilation of the old system into a single score. There were 2 that made this score of 7.50 then rounded to 8.

Posted by FoxBat ( ..xxx.xxx ) at 2003-12-07 17:47:00

Well now this is interesting. Ultimately I think placeables aren't too workable though with all the lag, and even beyond that, the problem remains that ranged attacks go right through all placeables. So I was looking to make multiple pathways through a level and then you have closed doors or other obstacles seal off some of the options. *However*, I was stuck on the main difficulty of a simple algorithm that could generate a random dungeon yet ensure that there would always be a valid path from point A to point B, yet not take forever to compute. So I'm interested in how you got around this issue in your random placeable maze.

Posted by Lucky Day ( ..xxx.xxx ) at 2003-07-05 09:16:00

Hmm..rogue aka Nethack comes to mind...

Posted by Deva Bryson Winblood ( ..xxx.xxx ) at 2003-01-08 13:10:00

Oh, you need to put a link to your demo module here so
people can at least see your screenshots... I think it
will help this script be accepted better for you.

Posted by Deva Bryson Winblood ( ..xxx.xxx ) at 2003-01-08 13:08:00

I think someone could do this for you. All that really
needs to be done is reskinning the cages. So, you would
not even need a new model.

If I knew about reskinning I'd see what I can do.

I'll pass the word around and see if we can get you some
help.

Deva

Posted by Blight ( ..xxx.xxx ) at 2003-01-08 12:02:00

I know what you mean about the different 'looks' using
other building blocks. It's something I'd like to do, but
I need to find good models first. It would be nice if the
models were the same size (2 meters), but I think that
wouldn't be that hard to work around.

One model I saw yesterday that I think I may try to use is
still basically the cage theme. Someone took the cage
apart and let you use the walls as placeables.

Posted by Deva Bryson Winblood ( ..xxx.xxx ) at 2003-01-08 11:40:00

This has a lot of potential. Cool script!!

However, now we just need some people to make you some
variations that you can use as building blocks other than
the cage...

THESE WOULD BE NICE:
Natural Cavern Look
Hedge Maze Look
Dungeon Look
And Castle Interior Look

IF you could get four placeables and use a simple AREA
switch on a placeable to let the random script choose
which placeable to use that would be excellent. Of
course, a modeler needs to make the other building blocks
first.

I wanted to congratulate you though this is a pretty cool
thing.

Look into the varying levels of water placeable that was
recently released (don't have a link) and that would be
also good to add into the options of your script.

This script has a lot of room for growth and has
tremendous potential...

I went ahead and voted on this one...

Deva Bryson Winblood

You must be Logged In to post comments in this section.