Example #1
0
        private void HelpForm_Load(object sender, EventArgs e)
        {
            string sHelpContent = String.Empty;

            try
            {
                sHelpContent = TokenUtilities.GetEmbeddedText("MassiveDarknessRandomDungeonGenerator.MDRandomDungeonGeneratorHelpContents.rtf");
            }
            catch (Exception exHelp)
            {
                // use default help content
                sHelpContent = @"{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Courier New;}{\f1\fnil\fcharset2 Symbol;}}" +
                               @" {\*\generator Msftedit 5.41.21.2510;}\viewkind4\uc1\pard\fs22 Unable to load About contents: " + exHelp.Message + @" \par}";
            }

            rtxtHelpContent.Rtf = sHelpContent;
        }
Example #2
0
        private void ParseConfigFile(string filename)
        {
            try
            {
                string      sConfigContents = TokenUtilities.GetEmbeddedText("MassiveDarknessRandomDungeonGenerator.MassiveDarknessInfo.cfg");
                XmlDocument xmlDoc          = new XmlDocument();
                xmlDoc.LoadXml(sConfigContents);

                // Extract the Tile sets
                XmlNodeList xmlTileSets = xmlDoc.GetElementsByTagName("TileSet");
                foreach (XmlNode xmlTileSet in xmlTileSets)
                {
                    TileSet newTileSet = new TileSet(xmlTileSet);
                    lstTilesets.Items.Add(newTileSet);
                }

                // Extract the Chips
                XmlNodeList xmlChips = xmlDoc.GetElementsByTagName("Chip");
                foreach (XmlNode xmlChip in xmlChips)
                {
                    Chip newChip = new Chip(xmlChip);
                    lstChips.Add(newChip);

                    switch (newChip.Name.ToLower())
                    {
                    case "start":
                        chpStart = newChip;
                        break;

                    case "exit":
                        chpExit = newChip;
                        break;

                    case "door":
                        chpDoor = newChip;
                        break;

                    case "bridge":
                        chpBridge = newChip;
                        break;

                    case "lvl1":
                        chpLevel1 = newChip;
                        break;

                    case "lvl2":
                        chpLevel2 = newChip;
                        break;

                    case "lvl3":
                        chpLevel3 = newChip;
                        break;

                    case "lvl4":
                        chpLevel4 = newChip;
                        break;

                    case "lvl5":
                        chpLevel5 = newChip;
                        break;

                    default:
                        break;
                    }
                }

                // Extract the Dice
                XmlNodeList xmlDice = xmlDoc.GetElementsByTagName("Die");
                foreach (XmlNode xmlDie in xmlDice)
                {
                    Die newDie = new Die(xmlDie);
                    lstDice.Add(newDie);
                    switch (newDie.Name.ToLower())
                    {
                    case "red":
                        dieRed = newDie;
                        break;

                    case "green":
                        dieGreen = newDie;
                        break;

                    default:
                        break;
                    }
                }

                // Validate the extraction of the Chips and Dice
                if ((null == chpStart) || (null == chpExit) || (null == chpDoor) || (null == chpBridge))
                {
                    sLoadErrors += Environment.NewLine + "Error parsing configuration file: Chip extraction failed.";
                }
                if ((null == chpLevel1) || (null == chpLevel2) || (null == chpLevel3) || (null == chpLevel4) || (null == chpLevel5))
                {
                    sLoadErrors += Environment.NewLine + "Error parsing configuration file: Chip Level extraction failed.";
                }
                if ((null == dieRed) || (null == dieGreen))
                {
                    sLoadErrors += Environment.NewLine + "Error parsing configuration file: Die extraction failed.";
                }
            }
            catch (Exception exXMLParse)
            {
                sLoadErrors = "Error parsing configuration file:" + Environment.NewLine + Environment.NewLine + exXMLParse.Message;
            }
        }
Example #3
0
        public void PerformSummaryLayout(Graphics grDungeon, StringBuilder sbBGMapEditorFileContents)
        {
            // Load the summary tile image
            Image iTileImage = TokenUtilities.GetTokenImage(this, false, "", true);

            if (null != iTileImage)
            {
                grDungeon.DrawImage(iTileImage, new Rectangle(ptLayoutTileLayoutLocation.X, ptLayoutTileLayoutLocation.Y, iTileImage.Width, iTileImage.Height));
            }
            // Add the current summary tile to the MAP file
            sbBGMapEditorFileContents.AppendLine(sBGMapEditorLayoutTilePath + ";tile;" + ptLayoutTileLayoutLocation.X.ToString() + "x" + ptLayoutTileLayoutLocation.Y.ToString() + ";5");

            // Add the bridge
            if (null != cBridge)
            {
                Point ptBridgeLocation = new Point(ptLayoutTileLayoutLocation.X, ptLayoutTileLayoutLocation.Y);

                switch (iConnectedCorridorZoneEdge)
                {
                case 1:
                    ptBridgeLocation.Offset(2 * (iLayoutTileWidth / 3), iLayoutTileHeight);
                    break;

                case 2:
                    ptBridgeLocation.Offset(iLayoutTileWidth / 3, iLayoutTileHeight);
                    break;

                case 3:
                    ptBridgeLocation.Offset(0, iLayoutTileHeight);
                    break;

                case 4:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.LayoutTileHeight, 2 * (iLayoutTileHeight / 3));
                    break;

                case 5:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.LayoutTileHeight, iLayoutTileHeight / 3);
                    break;

                case 6:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.LayoutTileHeight, 0);
                    break;

                case 7:
                    ptBridgeLocation.Offset(0, -1 * cBridge.LayoutTileHeight);
                    break;

                case 8:
                    ptBridgeLocation.Offset(iLayoutTileWidth / 3, -1 * cBridge.LayoutTileHeight);
                    break;

                case 9:
                    ptBridgeLocation.Offset(2 * (iLayoutTileWidth / 3), -1 * cBridge.LayoutTileHeight);
                    break;

                case 10:
                    ptBridgeLocation.Offset(iLayoutTileWidth, 0);
                    break;

                case 11:
                    ptBridgeLocation.Offset(iLayoutTileWidth, iLayoutTileHeight / 3);
                    break;

                case 12:
                    ptBridgeLocation.Offset(iLayoutTileWidth, 2 * (iLayoutTileHeight / 3));
                    break;

                default:
                    break;
                }
                sbBGMapEditorFileContents.AppendLine(cBridge.BGMapEditorLayoutTilePath + ";tile;" + ptBridgeLocation.X.ToString() + "x" + ptBridgeLocation.Y.ToString() + ";5");

                Image iBridgeImage = TokenUtilities.GetTokenImage(cBridge, false, "", true);
                if (null != iBridgeImage)
                {
                    grDungeon.DrawImage(iBridgeImage, new Rectangle(ptBridgeLocation.X, ptBridgeLocation.Y, iBridgeImage.Width, iBridgeImage.Height));
                }
            }
        }
Example #4
0
        public void PerformLayout(Graphics grDungeon, StringBuilder sbBGMapEditorFileContents, bool bUseFullColorTiles)
        {
            // Load the tile image
            Image iTileImage = TokenUtilities.GetTokenImage(this, bUseFullColorTiles);

            if (null != iTileImage)
            {
                grDungeon.DrawImage(iTileImage, new Rectangle(ptDungeonLayoutLocation.X, ptDungeonLayoutLocation.Y, iTileImage.Width, iTileImage.Height));
            }
            // Add the current tile to the MAP file
            if (true == bUseFullColorTiles)
            {
                sbBGMapEditorFileContents.AppendLine(sBGMapEditorFullColorTilePath + ";tile;" + ptDungeonLayoutLocation.X.ToString() + "x" + ptDungeonLayoutLocation.Y.ToString() + ";25");
            }
            else
            {
                sbBGMapEditorFileContents.AppendLine(sBGMapEditorTilePath + ";tile;" + ptDungeonLayoutLocation.X.ToString() + "x" + ptDungeonLayoutLocation.Y.ToString() + ";25");
            }

            // Add the bridge
            if (null != cBridge)
            {
                string sBridgeTokenPath = cBridge.BGMapEditorTilePath;
                Point  ptBridgeLocation = new Point(ptDungeonLayoutLocation.X, ptDungeonLayoutLocation.Y);

                switch (iConnectedCorridorZoneEdge)
                {
                case 1:
                    ptBridgeLocation.Offset(2 * (iWidth / 3), iHeight);
                    break;

                case 2:
                    ptBridgeLocation.Offset(iWidth / 3, iHeight);
                    break;

                case 3:
                    ptBridgeLocation.Offset(0, iHeight);
                    break;

                case 4:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.Height, 2 * (iHeight / 3));
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                case 5:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.Height, iHeight / 3);
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                case 6:
                    // It is rotated 90 degrees, so use the Height for the X-width offset
                    ptBridgeLocation.Offset(-1 * cBridge.Height, 0);
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                case 7:
                    ptBridgeLocation.Offset(0, -1 * cBridge.Height);
                    break;

                case 8:
                    ptBridgeLocation.Offset(iWidth / 3, -1 * cBridge.Height);
                    break;

                case 9:
                    ptBridgeLocation.Offset(2 * (iWidth / 3), -1 * cBridge.Height);
                    break;

                case 10:
                    ptBridgeLocation.Offset(iWidth, 0);
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                case 11:
                    ptBridgeLocation.Offset(iWidth, iHeight / 3);
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                case 12:
                    ptBridgeLocation.Offset(iWidth, 2 * (iHeight / 3));
                    sBridgeTokenPath = sBridgeTokenPath.Replace("r_0.png", "r_90.png");
                    break;

                default:
                    break;
                }
                sbBGMapEditorFileContents.AppendLine(sBridgeTokenPath + ";chip;" + ptBridgeLocation.X.ToString() + "x" + ptBridgeLocation.Y.ToString() + ";0");

                Image iBridgeImage = TokenUtilities.GetTokenImage(cBridge, false, sBridgeTokenPath);
                if (null != iBridgeImage)
                {
                    grDungeon.DrawImage(iBridgeImage, new Rectangle(ptBridgeLocation.X, ptBridgeLocation.Y, iBridgeImage.Width, iBridgeImage.Height));
                }
            }

            // Add the start marker
            int iStartZone = 0;

            if (null != cStart)
            {
                iStartZone = TokenUtilities.DetermineFarthestZone(iConnectedCorridorZone, lstCorridorZones);
                // Determine where the center of the start zone is, then offset the point so that the start token is centered in the zone
                Point ptStart = TokenUtilities.DetermineZoneCenter(this, iStartZone);
                ptStart.Offset(-1 * (cStart.Width / 2), -1 * (cStart.Height / 2));

                sbBGMapEditorFileContents.AppendLine(cStart.BGMapEditorTilePath + ";chip;" + ptStart.X.ToString() + "x" + ptStart.Y.ToString() + ";0");

                Image imgStartImage = TokenUtilities.GetTokenImage(cStart);
                if (null != imgStartImage)
                {
                    grDungeon.DrawImage(imgStartImage, new Rectangle(ptStart.X, ptStart.Y, cStart.Width, cStart.Height));
                }
            }

            // Add the exit marker
            int iExitZone = 0;

            if (null != cExit)
            {
                iExitZone = TokenUtilities.DetermineFarthestZone(iPreviousConnectedCorridorZone, lstCorridorZones);
                // Determine where the center of the exit zone is, then offset the point so that the exit token is centered in the zone
                Point ptExit = TokenUtilities.DetermineZoneCenter(this, iExitZone);
                ptExit.Offset(-1 * (cExit.Width / 2), -1 * (cExit.Height / 2));

                sbBGMapEditorFileContents.AppendLine(cExit.BGMapEditorTilePath + ";chip;" + ptExit.X.ToString() + "x" + ptExit.Y.ToString() + ";0");

                Image imgExitImage = TokenUtilities.GetTokenImage(cExit);
                if (null != imgExitImage)
                {
                    grDungeon.DrawImage(imgExitImage, new Rectangle(ptExit.X, ptExit.Y, cExit.Width, cExit.Height));
                }
            }

            // Add the level marker
            // ** The level marker must go in a cooridor
            // - Give preference to the center of the tile
            // - Do not put the level marker in the same zone as the start or Exit marker
            int iSelectedZone = 5;

            if (false == lstCorridorZones.Contains(5))
            {
                // randomly choose another zone, since the center of the tile is not a cooridor
                ArrayList lstPossibleLevelCorridorZones = new ArrayList(lstCorridorZones);
                if (null != cStart)
                {
                    // This is a START tile, exclude the start zone
                    lstPossibleLevelCorridorZones.Remove(iStartZone);
                }
                else if (null != cExit)
                {
                    // This is an Exit tile, exclude the start zone
                    lstPossibleLevelCorridorZones.Remove(iExitZone);
                }
                int iZoneIndex = TokenUtilities.rndGenerator.Next(0, lstPossibleLevelCorridorZones.Count);
                iSelectedZone = (int)(lstPossibleLevelCorridorZones[iZoneIndex]);
            }
            // Determine where the center of the selected zone is, then offset the point so that the level token is centered in the zone
            Point ptLevel = TokenUtilities.DetermineZoneCenter(this, iSelectedZone);

            ptLevel.Offset(-1 * (cLevel.Width / 2), -1 * (cLevel.Height / 2));

            sbBGMapEditorFileContents.AppendLine(cLevel.BGMapEditorTilePath + ";chip;" + ptLevel.X.ToString() + "x" + ptLevel.Y.ToString() + ";0");

            Image imgLevelImage = TokenUtilities.GetTokenImage(cLevel);

            if (null != imgLevelImage)
            {
                grDungeon.DrawImage(imgLevelImage, new Rectangle(ptLevel.X, ptLevel.Y, cLevel.Width, cLevel.Height));
            }

            // Add the doors
            if (0 < iDoors)
            {
                // Get a list of all possible door locations, based upon the corridors on the tile
                ArrayList lstAvailableDoorLocations = TokenUtilities.DetermineAvailableDoorLocations(lstCorridorZones);

                for (int iDoorIterator = 0; iDoorIterator < iDoors; iDoorIterator++)
                {
                    if (0 >= lstAvailableDoorLocations.Count)
                    {
                        // No available locations left
                        break;
                    }

                    // Determine door location
                    int    iDoorIndex   = TokenUtilities.rndGenerator.Next(0, lstAvailableDoorLocations.Count);
                    string sDoorToPlace = (string)(lstAvailableDoorLocations[iDoorIndex]);
                    // Remove the selected door placement so that it cannot be used again
                    lstAvailableDoorLocations.Remove(sDoorToPlace);
                    string[] asDoorToPlaceComponents = sDoorToPlace.Split("-".ToCharArray());
                    // Wastefully create a new point here, as we need to declare it outside of the If statement below
                    Point  ptDoorLocation = new Point(ptDungeonLayoutLocation.X, ptDungeonLayoutLocation.Y);
                    int    iDoorZone;
                    string sDoorTokenPath = cDoor.BGMapEditorTilePath;
                    if (true == int.TryParse(asDoorToPlaceComponents[0], out iDoorZone))
                    {
                        ptDoorLocation = TokenUtilities.DetermineZoneCenter(this, iDoorZone);
                        switch (asDoorToPlaceComponents[1])
                        {
                        case "Top":
                            sDoorTokenPath = sDoorTokenPath.Substring(0, sDoorTokenPath.LastIndexOf("r_0.png")) + "r_180.png";
                            //sDoorTokenPath = sDoorTokenPath.Replace("r_0.png", "r_180.png");
                            // Offset the point up so that it is at the top, middle of the current zone
                            ptDoorLocation.Offset(0, -1 * (this.Height / 6));
                            // Now offset the door location by half of the door width and height
                            ptDoorLocation.Offset(-1 * (cDoor.Width / 2), -1 * (cDoor.Height / 2));
                            break;

                        case "Bottom":
                            // Offset the point up so that it is at the bottom, middle of the current zone
                            ptDoorLocation.Offset(0, (this.Height / 6));
                            // Now offset the door location by half of the door width and height
                            ptDoorLocation.Offset(-1 * (cDoor.Width / 2), -1 * (cDoor.Height / 2));
                            break;

                        case "Left":
                            sDoorTokenPath = sDoorTokenPath.Substring(0, sDoorTokenPath.LastIndexOf("r_0.png")) + "r_90.png";
                            // Offset the point up so that it is at the left, middle of the current zone
                            ptDoorLocation.Offset(-1 * (this.Width / 6), 0);
                            // Now offset the door location by half of the door width and height (swap width/height since the door is to be rotated 90 degrees)
                            ptDoorLocation.Offset(-1 * (cDoor.Height / 2), -1 * (cDoor.Width / 2));
                            break;

                        case "Right":
                        default:
                            sDoorTokenPath = sDoorTokenPath.Substring(0, sDoorTokenPath.LastIndexOf("r_0.png")) + "r_270.png";
                            // Offset the point up so that it is at the right, middle of the current zone
                            ptDoorLocation.Offset((this.Height / 6), 0);
                            // Now offset the door location by half of the door width and height (swap width/height since the door is to be rotated 270 degrees)
                            ptDoorLocation.Offset(-1 * (cDoor.Height / 2), -1 * (cDoor.Width / 2));
                            break;
                        }
                    }

                    sbBGMapEditorFileContents.AppendLine(sDoorTokenPath + ";chip;" + ptDoorLocation.X.ToString() + "x" + ptDoorLocation.Y.ToString() + ";0");

                    Image imgDoorImage = TokenUtilities.GetTokenImage(cDoor, false, sDoorTokenPath);
                    if (null != imgDoorImage)
                    {
                        grDungeon.DrawImage(imgDoorImage, new Rectangle(ptDoorLocation.X, ptDoorLocation.Y, imgDoorImage.Width, imgDoorImage.Height));
                    }
                }
            }
        }