예제 #1
0
        public void ParseRoomTemplates(
            AsyncRPGDataContext db_context,
            string template_path)
        {
            MobTypeSet mobTypeSet = new MobTypeSet();
            MobSpawnTableSet mobSpawnTableSet = new MobSpawnTableSet();

            // Clear out any existing room templates
            db_context.ExecuteCommand("DELETE FROM room_templates");

            // Get the mob type set from the DB
            mobTypeSet.Initialize(db_context);

            // Get the mob spawn templates from the DB
            mobSpawnTableSet.Initialize(db_context, mobTypeSet);

            // Read in each XML file and save it into the room templates table
            string[] templateFiles = Directory.GetFiles(template_path, "*.oel");

            if (templateFiles == null || templateFiles.Length == 0)
            {
                throw new Exception("RoomTemplateParser: No room template files (*.oel) found in directory: " + template_path);
            }

            {
                Dictionary<TypedFlags<MathConstants.eSignedDirection>, int> portalLayoutCounts =
                    new Dictionary<TypedFlags<MathConstants.eSignedDirection>, int>();
                bool anyRoomParsingErrors = false;

                foreach (string templateFile in templateFiles)
                {
                    string templateName = Path.GetFileNameWithoutExtension(templateFile);

                    RoomTemplate roomTemplate = null;
                    byte[] compressedNavCells = null;
                    byte[] compressedPVS = null;

                    // Parse the XML template from the file
                    XmlDocument doc = new XmlDocument();
                    doc.Load(templateFile);

                    // Parse the room template xml into a room template object
                    roomTemplate = new RoomTemplate(templateName, doc);

                    // Keep track of all of the unique portal layouts we encounter
                    if (portalLayoutCounts.ContainsKey(roomTemplate.PortalRoomSideBitmask))
                    {
                        portalLayoutCounts[roomTemplate.PortalRoomSideBitmask] += 1;
                    }
                    else
                    {
                        portalLayoutCounts.Add(roomTemplate.PortalRoomSideBitmask, 1);
                    }

                    // Extract the nav-mesh and visibility data in compressed form to save into the DB
                    roomTemplate.NavMeshTemplate.ToCompressedData(out compressedNavCells, out compressedPVS);

                    // Remove everything from the template XML that we wont care about at runtime
                    RemoveXmlNodeByXPath(doc, "/level/Floor");
                    RemoveXmlNodeByXPath(doc, "/level/Walls");
                    RemoveXmlNodeByXPath(doc, "/level/BackgroundObjects");
                    RemoveXmlNodeByXPath(doc, "/level/ForegroundObjects");
                    RemoveXmlNodeByXPath(doc, "/level/NavMesh");

                    if (ValidateRoomTemplate(
                            templateName,
                            roomTemplate,
                            mobSpawnTableSet,
                            compressedNavCells,
                            compressedPVS))
                    {
                        // Save the XML back into string
                        StringWriter stringWriter = new StringWriter();
                        XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);
                        doc.WriteTo(xmlWriter);

                        RoomTemplates dbRoomTemplate =
                            new RoomTemplates
                            {
                                Name = templateName,
                                XML = stringWriter.ToString(),
                                CompressedNavMesh = compressedNavCells,
                                CompressedVisibility = compressedPVS
                            };

                        db_context.RoomTemplates.InsertOnSubmit(dbRoomTemplate);
                        db_context.SubmitChanges();

                        _logger.LogInfo("RoomTemplateParser: Added Room Template:");
                        _logger.LogInfo(templateFile);
                    }
                    else
                    {
                        anyRoomParsingErrors = true;
                    }
                }

                // Verify all possible door-side combinations are represented in the template file set
                if (portalLayoutCounts.Keys.Count < k_expectedRoomLayouts.Length)
                {
                    foreach (TypedFlags<MathConstants.eSignedDirection> expectedLayout in k_expectedRoomLayouts)
                    {
                        if (!portalLayoutCounts.ContainsKey(expectedLayout))
                        {
                            _logger.LogError(
                                string.Format(
                                "RoomTemplateParser: Missing expected room layout: {0}{1}{2}{3}{4}{5}",
                                expectedLayout.Test(MathConstants.eSignedDirection.positive_x) ? "X+" : "",
                                expectedLayout.Test(MathConstants.eSignedDirection.negative_x) ? "X-" : "",
                                expectedLayout.Test(MathConstants.eSignedDirection.positive_y) ? "Y+" : "",
                                expectedLayout.Test(MathConstants.eSignedDirection.negative_y) ? "Y-" : "",
                                expectedLayout.Test(MathConstants.eSignedDirection.positive_z) ? "Z+" : "",
                                expectedLayout.Test(MathConstants.eSignedDirection.negative_z) ? "Z-" : ""));

                            anyRoomParsingErrors = true;
                        }
                    }
                }

                if (anyRoomParsingErrors)
                {
                    throw new Exception("RoomTemplateParser: Failed to parse all room templates");
                }
            }
        }
        public void ParseMobSpawnTables(
            AsyncRPGDataContext db_context,
            string mob_spawn_tables_file_path)
        {
            MobTypeSet mobTypeSet = new MobTypeSet();

            // Load the mob spawn types from the DB
            mobTypeSet.Initialize(db_context);

            // Clear out any existing room templates
            db_context.ExecuteCommand("DELETE FROM mob_spawn_table_entries");
            db_context.ExecuteCommand("DELETE FROM mob_spawn_tables");

            // Read in the given JSON file and save it into the mob spawn table db table
            string jsonString = "";
            JSONMobSpawnTableSet jsonMobSpawnTableSet = null;

            // Read the spawn table file into a string
            using (StreamReader streamReader = new StreamReader(mob_spawn_tables_file_path))
            {
                jsonString = streamReader.ReadToEnd();

                if (jsonString.Length == 0)
                {
                    throw new Exception("MobSpawnTableParser: Mob spawn table file empty:" + mob_spawn_tables_file_path);
                }
            }

            // Parse the JSON into an object
            jsonMobSpawnTableSet = JsonMapper.ToObject<JSONMobSpawnTableSet>(jsonString);

            // Parse and verify each spawn table given
            {
                Dictionary<string, JSONMobSpawnTable> validMobSpawnTables = new Dictionary<string, JSONMobSpawnTable>();
                Dictionary<string, int> spawnTableNameToId = new Dictionary<string, int>();

                foreach (JSONMobSpawnTable jsonMobSpawnTable in jsonMobSpawnTableSet.mob_spawn_table_set)
                {
                    if (ValidateMobSpawnTable(jsonMobSpawnTable, validMobSpawnTables))
                    {
                        bool validTable = true;

                        // Verify each entry references either a valid spawn table or mob type
                        // and has a valid weight
                        foreach (JSONMobSpawnTableEntry jsonSpawnTableEntry in jsonMobSpawnTable.entries)
                        {
                            if (!ValidateMobSpawnTableEntry(
                                    jsonSpawnTableEntry,
                                    mobTypeSet,
                                    validMobSpawnTables))
                            {
                                validTable = false;
                            }
                        }

                        // If all the table entries look good, add the spawn table to the DB
                        if (validTable)
                        {
                            // Insert the spawn table first
                            MobSpawnTables dbMobSpawnTable = new MobSpawnTables
                            {
                                MobSpawnTableName = jsonMobSpawnTable.mob_spawn_table_name,
                            };

                            db_context.MobSpawnTables.InsertOnSubmit(dbMobSpawnTable);
                            db_context.SubmitChanges();

                            // Then insert all the entries associated with the table
                            foreach (JSONMobSpawnTableEntry jsonEntry in jsonMobSpawnTable.entries)
                            {
                                MobSpawnTableEntries dbMobSpawnTableEntry = null;

                                if (jsonEntry.mob_spawn_table_name.Length > 0)
                                {
                                    dbMobSpawnTableEntry = new MobSpawnTableEntries
                                    {
                                        MobSpawnTableID = dbMobSpawnTable.MobSpawnTableID,
                                        ReferenceID = spawnTableNameToId[jsonEntry.mob_spawn_table_name],
                                        ReferenceIsMobType = false,
                                        Weight = jsonEntry.weight
                                    };
                                }
                                else
                                {
                                    dbMobSpawnTableEntry = new MobSpawnTableEntries
                                    {
                                        MobSpawnTableID = dbMobSpawnTable.MobSpawnTableID,
                                        ReferenceID = mobTypeSet.GetMobTypeByName(jsonEntry.mob_type_name).ID,
                                        ReferenceIsMobType = true,
                                        Weight = jsonEntry.weight
                                    };
                                }

                                db_context.MobSpawnTableEntries.InsertOnSubmit(dbMobSpawnTableEntry);
                                db_context.SubmitChanges();
                            }

                            _logger.LogInfo("MobSpawnTableParser: Added Mob Spawn Table:");
                            _logger.LogInfo(jsonMobSpawnTable.mob_spawn_table_name);

                            // Keep track of each valid table added and what it's DB id is
                            validMobSpawnTables.Add(
                                jsonMobSpawnTable.mob_spawn_table_name,
                                jsonMobSpawnTable);
                            spawnTableNameToId.Add(
                                jsonMobSpawnTable.mob_spawn_table_name,
                                dbMobSpawnTable.MobSpawnTableID);
                        }
                        else
                        {
                            throw new Exception("MobSpawnTableParser: Problem(s) validating mob spawn table entries: " + jsonMobSpawnTable.mob_spawn_table_name);
                        }
                    }
                    else
                    {
                        throw new Exception("MobSpawnTableParser: Problem(s) validating mob spawn table: " + jsonMobSpawnTable.mob_spawn_table_name);
                    }
                }
            }
        }