A large model driven script tour data structure automatic generation system

Abstract

The application relates to the technical field of model data processing, and discloses a large model driven script tour data structure automatic generation system, which collects two types of original texts of a single script and mapping texts of matching templates, generates configuration compliance marks through double data set checking and comparison, generates key authorization marks in combination with AES-256 encryption, completes compensation actions in combination with correction rules, outputs a layered encryption configuration file, collects a single natural language instruction and a single page source code, generates instruction effective marks, generates combination compatible marks through full pairing checking of a capability matrix, and outputs script tour structured basic data after iteration correction; generates local correlation checking marks in combination with incremental differential data, and executes multi-dimensional compensation; splits and outputs layered subsets, generates entity fusion data sets and incremental update local data sets; generates version security marks through new and old version hashing and field comparison, and generates a producible full-link structured data set through closed loop correction.

Description

Technical Field

[0001] This invention belongs to the field of model data processing technology, specifically a large model-driven automatic generation system for script game data structures. Background Technology

[0002] Existing script game data structure generation solutions have significant drawbacks and shortcomings in multiple aspects such as configuration management, instruction parsing, multimodal fusion, incremental updates, and version control; In existing technologies, the configuration side lacks a two-way verification and dynamic completion mechanism for mapping fields between front-end and back-end interfaces, resulting in the inability to automatically detect and repair missing fields and type errors. Furthermore, encrypted configurations lack integrity verification and authorization binding, making it difficult to block configuration tampering and unauthorized access in real time. Natural language commands and page source code adjustments rely on manual, item-by-item modifications. The semantic parsing results of large models lack cross-validation with configuration specifications and multi-terminal adaptation requirements, leading to repeated trial and error for command conflicts and page rendering anomalies. Multimodal materials are stored in isolation without unified entity ID merging, and the semantic similarity matching threshold for text and image entities is fixed. When real-world puzzle fields are missing, they cannot be automatically filled in from image or location data. Cross-domain permission layering is coarse, and unauthorized leakage easily occurs between the host's private content and what is visible to players. Incremental updates use a full-coverage approach, making it impossible to accurately locate the break in the connection between changed fragments and the original structure. Computing power consumption lacks dynamic estimation based on the change ratio. Version iterations rely solely on hash values ​​to determine tampering, failing to distinguish between normally evolving fields and conflicting fields. Differences in fields outside the whitelist cannot be automatically isolated, and missing required fields in links and broken cross-link mappings lack systematic verification.

[0003] To address this, the present invention provides a large-model-driven automatic generation system for script game data structures. Summary of the Invention

[0004] The purpose of this invention is to provide a large-model-driven automatic generation system for script-based game data structures. It establishes an iterative correction closed loop for dynamic matching of multi-stage local association verification markers and compensation rules. Through dual-dataset XOR verification, semantic sequence XOR, full pairing matrix, multimodal cosine merging, and link whitelist mechanisms, it systematically solves problems such as configuration tampering, instruction conflicts, entity isolation, incremental breakage, and version misjudgment. To address the aforementioned problems in the prior art, this invention achieves this through the following technical solutions: This invention provides a large-model-driven automatic generation system for script game data structures, which specifically includes the following modules: Configure the encryption module: Collect two types of original text from a single script and the mapping text from the matching template interface, generate a configuration compliance mark through dual dataset verification and comparison, generate a key authorization mark by combining AES-256 encryption, complete the compensation action by combining correction rules, and output a layered encrypted configuration file; Instruction adaptation module: Combines the decrypted data of the layered encrypted configuration file, collects single natural language instructions and single page source code, generates valid instruction tags, generates combined compatibility tags through full pairing verification of the capability matrix, and outputs the structured basic data of the script game after iterative correction; Layered fusion module: Combines the structured basic data of script games, collects three-layer permission and multimodal material data, combines incremental differential data to generate local correlation verification markers, performs multi-dimensional compensation, splits and outputs layered subsets and generates entity fusion dataset and incrementally updated local dataset; Link verification module: Combining hierarchical subsets, entity fusion datasets and incrementally updated local datasets, it collects input subsets to generate structurally complete tags, generates version security tags by comparing old and new version hashes with fields, and generates a production-ready full-link structured dataset through closed-loop correction.

[0005] The beneficial effects of this invention are as follows: 1. Configure compliance tags and key authorization tags for dual-tag cross-verification. Convert the encrypted hash and integrity tag into binary sequences and XOR them bit by bit with the permission level to achieve joint and accurate location of configuration tampering and unauthorized access. Introduce dual-feature sequence XOR operation to verify the semantic parsing results of the large model. Generate a combination compatibility tag by traversing the capability number and parameter full pairing matrix to trigger signal consistency, parameter same name and circular dependency triple conditions, completely blocking instruction conflicts and dependency missing. 2. Construct a dynamic merging mechanism for multimodal entity semantic similarity. Use the cosine similarity between text item names and image OCR clues to determine the same source text and image entities, and then associate them with spatial locations to form a unified three-modal ID. Dynamically calculate the computing power consumption range based on the incremental change ratio. The link layer has a preset whitelist mechanism that includes plot, level, and response actions. Distinguish between normal evolution differences and version conflicts field by field. Combine the five sets of input subsets to classify them by link prefix and check the integrity of cross-link mapping. Attached Figure Description

[0006] The invention will now be further described with reference to the accompanying drawings.

[0007] Figure 1 This is a schematic diagram of the structure of a large model-driven script game data structure automatic generation system provided by the present invention; Figure 2 This is a schematic diagram of the instruction adaptation module structure of a large model-driven script game data structure automatic generation system provided by the present invention. Figure 3 This is a schematic diagram of the hierarchical fusion module structure of a large model-driven script game data structure automatic generation system provided by the present invention. Detailed Implementation

[0008] To make the technical means, creative features, objectives and effects of this invention easier to understand, the invention will be further described below in conjunction with specific embodiments.

[0009] Example: Please refer to Figure 1 , Figure 2 as well as Figure 3 As shown in the embodiment of the present invention, a large model-driven automatic generation system for script game data structures specifically includes the following modules: Configure the encryption module: Collect two types of original text from a single script and the mapping text from the matching template interface, generate a configuration compliance mark through dual dataset verification and comparison, generate a key authorization mark by combining AES-256 encryption, complete the compensation action by combining correction rules, and output a layered encrypted configuration file; In a specific embodiment, the security backend service module performs single-script targeted data collection, collecting two types of raw text in a single instance: basic information and gameplay rule information for a single script. Synchronously collect the interface mapping relationship text of the current script matching template within the standardized front-end H5 template module; After the data collection is completed, through the process of field-by-field JSON syntax validation and data type validation, two types of validation data are extracted: field missing markers and field data type error markers. These are then encapsulated to generate a JSON specification validation result dataset. Each record in the JSON specification validation result dataset corresponds to a field to be validated. The record structure includes the field name, field path, validation status code, and error type code. The field path is located using the JSONPointer standard format. A validation status code of 0 indicates that the validation passed, 1 indicates that the field is missing, and 2 indicates that the data type does not match. The error type code records the specific type of mismatch. By reading the processing of the template's built-in interface definition file, two types of matching data are extracted: the interface request field mapping table and the front-end template rendering field mapping table. These are then encapsulated to generate a standard dataset for front-end and back-end interface matching. The front-end and back-end interface matching standard dataset contains a set of field mapping entries. Each mapping entry records the template interface field name, the corresponding back-end data field path, and the field data type constraint. The field path also adopts the JSONPointer standard format. The AES encrypted JSON configuration management unit performs segmented targeted data collection, receives standardized script raw configuration data, and collects only two types of core segmented data according to the four-segment configuration classification standard: public basic configuration and host private content configuration. The segments are stored independently and not mixed. Synchronously acquire the module authorization identities and permission levels pre-stored in the system; After the data collection is completed, the segmented configuration data is encrypted using the AES-256 encryption algorithm. Two types of verification data are extracted: the file encryption hash value and the configuration field integrity flag. These are then packaged to generate an encrypted configuration file verification dataset. The file encryption hash value is calculated from the original plaintext configuration data before encryption using the SHA-256 algorithm. The file encryption hash value is 256 bits long and is stored in the form of a 64-bit hexadecimal string. The integrity flag of the configuration field is calculated by the CRC-64 check algorithm on the encrypted ciphertext data. The check value is a 64-bit unsigned integer and is stored as a 16-bit hexadecimal string. Each record in the encrypted configuration file verification dataset contains: a configuration segment identifier, an encrypted hash value string, an integrity verification value string, and an encrypted timestamp; By reading the system authorization configuration information, two types of permission data are extracted: the authorization module identity identifier and the private configuration access permission level. These are then encapsulated to generate a module key access permission dataset. Iterate through each field validation entry in the JSON specification validation result dataset and compare each target field with the field mapping table of the front-end and back-end interface matching standard dataset. If a field exists in both the JSON specification validation result dataset and the front-end and back-end interface matching standard dataset, then the target field is marked as a compliant field. If a field exists in the JSON specification validation result dataset but not in the field mapping table of the front-end and back-end interface matching standard dataset, the target field is marked as an abnormal field and assigned a unique abnormal field number. If a field exists in the field mapping table of the standard dataset that matches the front-end and back-end interfaces but does not exist in the JSON specification validation result dataset, the target field is marked as a missing field and assigned a unique missing field number. After all fields have been compared, all abnormal field numbers and missing field numbers are summarized and packaged into a configuration compliance tag; The encrypted hash value of the file and the integrity flag of the configuration field in the encrypted configuration file verification dataset are converted into the first binary sequence according to the preset encoding rules; Convert the authorized module identities and permission levels in the module key access permission dataset into a second binary sequence according to the same encoding rule; After aligning the lengths of the two sequences, perform an XOR operation bit by bit. Bits with a value of 1 in the result are marked as abnormal bits, and bits with a value of 0 are marked as normal bits. The abnormal bits are mapped back to the corresponding data items, and two types of correction and location information, namely the file tampering flag bit and the unauthorized access level flag bit, are extracted and encapsulated into a key authorization flag. The correction rules are divided into four categories: adjustment of compensation mapping parameter set pre-entered field missing compensation rules, cross-terminal template field mapping adjustment instructions, tampering interception compensation rules, and private configuration isolation adjustment rules. Read all anomaly location numbers and tag bits from the configuration compliance tag and key authorization tag, classify and summarize them according to anomaly type, and each type of anomaly corresponds to a unique anomaly identifier code; The anomaly identifier is matched with the preset rule key-value table in the adjustment compensation mapping parameter set. The compensation action is matched by the correction rule. The four compensation actions include: field missing compensation action, cross-end mapping adjustment action, tampering interception compensation action, and private configuration isolation action. The field missing compensation action is based on the field missing compensation rules. It automatically completes the script's standard fields and fills in the general default parameter values ​​for the marked missing fields. The cross-platform mapping adjustment action is based on the cross-platform template field mapping adjustment instruction. It reconstructs the script data transmission field arrangement order for the marked abnormal adaptation template and automatically aligns the mobile and PC template rendering interfaces. The tampering interception and compensation action is based on the tampering interception and compensation rules. It compares the abnormal encrypted hash values ​​of the marked files and automatically retrieves the original version of the encrypted file to overwrite the current file when a tampering mark is detected. The privacy configuration isolation action is based on the privacy configuration isolation adjustment rules. It splits the configuration read field range for the marked unauthorized access level and automatically removes the host's private tricks and hidden clue fields for ordinary access subjects. After all compensation actions are completed, the set intersection and XOR operations are performed again on the corrected data to generate the configuration compliance flag and key authorization flag again. Verify whether all the corresponding anomalies in the newly generated tags have been cleared, and compare the set of all anomaly field numbers and missing field numbers in the regenerated configuration compliance tags after compensation with the set of corresponding numbers in the original tags before compensation. If the compensated set is empty, it is determined that it has been cleared and the compensation is marked as successful; If the compensated set is not empty, it is determined that it has not been cleared, triggering secondary compensation and recording the compensation exception log. After successful verification, the layered encrypted configuration file is output.

[0010] Instruction adaptation module: Combines the decrypted data of the layered encrypted configuration file, collects single natural language instructions and single page source code, generates valid instruction tags, generates combined compatibility tags through full pairing verification of the capability matrix, and outputs the structured basic data of the script game after iterative correction; In a specific embodiment, a single user natural language adjustment command and configuration specification entries after decryption of the layered encrypted configuration file are collected, and semantic understanding and configuration specification matching are performed on the single natural language command; The single user natural language adjustment command is used as the input prompt word. At the same time, the set of field names in the configuration specification entries after the decryption of the layered encrypted configuration file is used as the context qualifier and concatenated after the input prompt word. The input is then used to perform semantic parsing on the large model. The large model outputs configuration modification execution actions, which are in JSON array format and encapsulated to generate a configuration semantic transformation parameter set. Collect the original text of a single page within a standardized front-end H5 template module, as well as the corresponding user's description of page style adjustment requirements; The process of performing syntax verification and multi-platform adaptation prediction on the original text of a single page through a large model pre-detection algorithm is used to extract the original H5 page text and source code syntax error markers, and encapsulate them to generate a set of page source code correction parameters. The configuration modification actions in the configuration semantic transformation parameter set are encoded into a first feature sequence according to the action type; The first feature sequence is a fixed-length binary bit string. The length of the bit string is equal to the total number of modifiable fields in the configuration specification entry. Each bit in the fixed-length binary bit string is arranged in the order of the field index. When there is a modification operation for the field in the configuration modification execution action array, the corresponding bit is 1, and when there is no modification operation, the corresponding bit is 0. The source code syntax error markers in the page source code correction parameter set are encoded into a second feature sequence according to the error type. The second feature sequence is a fixed-length binary bit string. The length of the bit string is equal to the total number of verifiable syntax nodes in the page source code. Each bit in the fixed-length binary bit string is arranged according to the parsing order of the syntax nodes. When the corresponding syntax node has an error marker, the corresponding bit is 1, and when there is no error marker, the corresponding bit is 0. If the length of the first feature sequence bit string is inconsistent with the length of the second feature sequence bit string, the maximum bit string length is taken as the unified length after alignment, and the feature sequence with the smallest bit string length is padded with 0s in the high bits until the length is consistent. After aligning the lengths of the first feature sequence bit string and the second feature sequence bit string, perform an XOR operation bit by bit. Bits with a result of 1 are marked as abnormal bits, and bits with a result of 0 are marked as normal bits. The abnormal points are classified by dimension, and two types of correction and positioning identifiers are extracted: configuration conflict points and page adaptation abnormal points, which are then encapsulated as valid instruction markers. Perform targeted on-demand retrieval and collection, retrieving basic information on a small number of capability objects required for the current script from the vector database; simultaneously collect two types of assembly-related information: capability numbers to be combined and preset execution constraints. Extract two types of basic data: unique capability identifiers and fixed capability parameter sets, and encapsulate them to generate a basic dataset of capability objects. Through the process of combining constraint parsing, two types of assembly-related data are extracted: the capability number to be combined and the capability execution sequence constraint. These are then encapsulated to generate a set of capability combination-related parameters. Based on the capability ID to be combined in the capability combination association parameter set, extract the complete parameters of the corresponding capability object from the capability object basic dataset to form a set of capability combinations to be verified. For each pair of capabilities in the set, perform pairwise comparisons to check for conflicts in execution order constraints and for missing prerequisite capabilities. The list of capability IDs to be combined in the capability combination association parameter set is used as the row set, and the complete parameters of each capability object in the capability object basic dataset are used as the column set to form a full pairing matrix of capability IDs and capability objects. Traverse each pairing unit in the matrix. For each pairing combination, check whether the trigger signal types in the execution constraints of the pairing combination are consistent, check whether there are conflicting parameters with the same name in the fixed parameter set of the pairing combination, and check whether there are circular dependencies in the execution order constraints of the pairing combination. Pairing combinations that pass all checks are marked as compatible combinations, and pairing combinations that fail any check are marked as conflicting combinations. Combinations with timing conflicts are assigned a unique timing conflict combination number, and combinations with missing dependencies are assigned a unique missing dependency capability number. After all combinations are compared, all conflicting and missing numbers are summarized and encapsulated into a combination compatibility tag; The adjustment of compensation mapping parameter set pre-entered configuration conflict correction compensation rules, page multi-terminal adaptation adjustment rules, timing conflict adjustment compensation rules, and dependency capability completion compensation rules are four types of correction rules; Read all point identifiers and numbers in the valid and combined compatibility markers of the read instruction, classify and summarize them according to configuration, page and capability dimensions, and assign a unique exception code to each type of exception. The classified anomaly codes are matched with the rule key-value table in the adjustment compensation mapping parameter set; The configuration conflict correction action is based on the configuration conflict correction compensation rules. For the marked configuration conflict points, the configuration modification actions with logical contradictions are automatically revoked, and a conflict-free standardized configuration instruction is regenerated and pushed to the AES encrypted JSON configuration management unit to update the encrypted configuration. The page multi-platform adaptation action is based on the page multi-platform adaptation adjustment rules. It automatically adjusts the page text size and component layout parameters for the marked page adaptation anomalies, and fixes the anomalies of text overflow on mobile devices and missing components on PC devices. The timing conflict reordering action is based on the timing conflict adjustment and compensation rules. It reorders the execution order constraints of the marked timing conflict combinations, splits the conflicting capability combinations, and adjusts the triggering conditions to eliminate execution timing disorder. The dependency capability completion action, based on the dependency capability completion compensation rules, automatically retrieves the corresponding preceding capability object from the vector database for the marked missing dependency capability number, and automatically supplements it to the corresponding position in the gameplay combination link.

[0011] After all the compensation calibrations corresponding to the four correction rules are completed, the XOR operation and product operation are re-executed on the corrected configuration instructions, page text, and capability combinations to generate instruction validity markers and combination compatibility markers again. Verify whether all corresponding abnormal points and conflict numbers have been cleared. If all are cleared, the compensation is marked as successful. If abnormalities still exist, a second iteration of compensation is triggered and the log is recorded. After the verification is passed, the structured basic data of the script game is output. The structured basic data of the script game includes: corrected encryption configuration, adapted page text fragments, and complete sets of conflict-free script game gameplay combination data.

[0012] Layered fusion module: Combines the structured basic data of script games, collects three-layer permission and multimodal material data, combines incremental differential data to generate local correlation verification markers, performs multi-dimensional compensation, splits and outputs layered subsets and generates entity fusion dataset and incrementally updated local dataset; In a specific embodiment, all roles and clues after the decryption of the layered encrypted configuration file are collected to obtain the three-layer data field range and clue allocation criteria. Through the entity relationship extraction process, two types of raw data, namely all character entities and all clue entities, are extracted and packaged to generate an unlayered raw script configuration dataset. Extract the visible field range of players and the exclusive field range of the host, and encapsulate them to generate a hierarchical permission isolation parameter set; Iterate through all entities and associated edges in the unlayered original script configuration dataset, and compare each entity or associated edge to see if it falls within the host-specific field defined in the layered permission isolation parameter set. Entities falling within the exclusive scope are marked as private entities, and the corresponding cross-domain association edges are marked as illegal association edges and assigned a unique illegal cross-domain association edge number; The distribution of key clues held by each role is statistically analyzed and compared with the preset clue balance distribution standard. Roles that exceed the balance range are marked as clue imbalance roles and assigned a unique clue imbalance role number. All illegal associated edge IDs and unbalanced role IDs are aggregated and encapsulated into hierarchical permission tags; The system independently collects materials for a single set of live-action scripts using three sub-channels, and collects text descriptions of character entities and props using the text sub-channel, which are then packaged to generate a script text entity dataset. The image sub-channel collects clue image materials, extracts OCR clue text and prop appearance features, and encapsulates them to generate an image parsing entity dataset. The spatial sub-channel collects map coordinates and mechanism number data of the secret room locations, extracts room coordinates and mechanism binding IDs, and encapsulates them to generate a spatial location entity dataset. Based on the prop entities in the script text entity dataset, semantic similarity matching is performed with the prop features in the image parsing entity dataset; Input the name text of the text prop entity and the OCR clue text of the image parsing entity into the pre-trained text embedding model respectively to generate the semantic vector of the name text and the semantic vector of the clue text, and calculate the cosine similarity between the two vectors. The cosine similarity value ranges from [-1, 1]. The preset merging condition is that if the similarity is greater than or equal to the similarity threshold, they are determined to be the same image and text entities, and if the similarity is lower than the similarity threshold, they are determined to be independent entities. The similarity threshold value ranges from [0.7, 0.8]. The successfully matched graphic entities are spatially associated with the props in the spatial point entity dataset. Entities with corresponding binding relationships are marked as homologous trimodal entities. After the script text entity dataset, image parsing entity dataset and spatial point entity dataset are all merged, the independent entities that cannot be matched are marked as matching deviation entities and assigned a unique matching deviation entity number. Entities that lack corresponding real-world puzzle-solving fields are marked as missing field entities and assigned a unique missing real-world puzzle-solving field number. All deviation entity numbers and missing field numbers are summarized and encapsulated into entity matching tags; Collect partial text fragments of the same script before and after revision, and automatically separate the changed content from the unchanged content through text comparison algorithms; By changing the processing steps of regional positioning and entity extraction, two types of change data are extracted: modified text fragments and corresponding changed entities. These are then encapsulated to generate a local dataset of script change fragments. Through the processing of extracting original data from the corresponding region, two types of original data are extracted: the original text before modification and the original entity association edges. These are then packaged to generate the original local dataset of the script without any changes.

[0013] Compare the entity sets in the two local datasets before and after the change, extract the newly added entities and the entities that disappeared, and mark them as change-related entities; By comparing the set of associated edges in the two sets of local datasets before and after the change, the broken associated edges are extracted and assigned a unique invalid associated edge number. The sum of the number of newly added entities and the number of disappeared entities in the local dataset of the changed fragment is taken as the total number of changed entities. The total number of original entities in the original local dataset of the script that has not been changed is added to the total number of changed entities to take the total number of entities in the entire script. The total number of changed entities is divided by the total number of entities in the entire script to obtain the data volume ratio, expressed as a percentage. Based on the standard computing power consumption value of the whole script reasoning, the data volume ratio is multiplied by the benchmark value to obtain the estimated computing power consumption range of the changed segment. The upper and lower fluctuation range of the estimated computing power consumption range is ±10% of the benchmark value; this is marked as the computing power occupation range of the changed data. The failed associated edge numbers and computing power occupancy ranges are summarized and encapsulated into a local association verification tag; The adjustment compensation mapping parameter set includes six types of correction rules: pre-entered cross-domain association deletion compensation rules, clue reallocation adjustment rules, entity ID normalization compensation rules, real-scene field completion adjustment rules, association link repair compensation rules, and computing power scheduling reduction adjustment rules. Read all numbers and interval identifiers from the hierarchical permission markers, entity matching markers, and local association verification markers, and classify and summarize them into three categories: permission dimension, entity dimension, and incremental dimension. Assign a unique exception code to each exception. The classified anomaly codes are matched one by one with the rule key-value table in the adjustment compensation mapping parameter set; The cross-domain association deletion action is based on the cross-domain association deletion compensation rules, and the association edge between the host's private entity and the player entity is automatically deleted based on the marked illegal cross-domain association edge number; The clue redistribution action is based on the clue redistribution adjustment rules. For the marked clues with unbalanced distribution, a clue ownership adjustment instruction is generated and pushed to the large model configuration interaction unit to redistribute key clues to lock the murderer. The entity ID normalization action is based on the entity ID normalization compensation rule. For entities with matching deviations, a globally unified entity ID is assigned to text, images, and space props that are from the same source. The real-scene field completion action is based on the real-scene field completion adjustment rules. For the marked missing real-scene puzzle field entities, the password information obtained from image recognition and the point triggering rules are extracted and added to the corresponding fields of the interactive event chain. The associated link repair action is based on the associated link repair compensation rules. For the marked failed associated edge number, the large model is called to perform local regeneration of substructure only for the changed fragment. The name, type, and description text of the newly added entity in the modified segment are concatenated into the input prompt word. At the same time, the name and relationship type of the original entity adjacent to the modified entity in the original local dataset of the script that has not been modified are added as contextual limiting information after the prompt word and input into the large model to perform local inference. The large model outputs a list of newly added associated edges and association types related to the input entities. The output format is a JSON array, and each element in the JSON array contains the source entity name, target entity name, association type, and association strength. The newly added associated edges in the output are automatically merged with the original associated edges in the original local dataset where the script has not been changed, forming a complete local structure after the change; The computing power scheduling reduction action is based on the computing power scheduling reduction adjustment rules, targeting the computing power occupancy range of the marked changed data; The difference operation, summation and merging operation, and difference operation are re-executed on the corrected hierarchical data, multimodal entities, and incremental structures to generate hierarchical subsets, entity fusion datasets, and incrementally updated local datasets again. Verify whether all corresponding anomaly numbers have been cleared and whether computing power usage falls within the preset reduction range. If all criteria are met, the compensation is marked as successful. If the criteria are not met, a second compensation is triggered and an anomaly log is recorded. After the verification is passed, the system automatically splits into hierarchical subsets, which include: player lightweight subset, host complete management subset, and real-world device control subset. At the same time, it outputs entity fusion dataset and incrementally updated local dataset.

[0014] Link verification module: Combining hierarchical subsets, entity fusion datasets and incrementally updated local datasets, it collects input subsets to generate structurally complete tags, generates version security tags by comparing old and new version hashes with fields, and generates a production-ready full-link structured dataset through closed-loop correction; In a specific embodiment, the script game data structure generation unit collects the input subset by combining hierarchical subsets, entity fusion datasets, and incrementally updated local datasets; The input subsets include: a complete capability combination dataset, an encrypted configuration parsing dataset, a corrected page text dataset, a hierarchical isolation permission dataset, and an entity fusion dataset; The five sets of input subsets are categorized and summarized according to the links, which include: story chain, level chain, and interactive event chain. The plot chain includes six required fields: script title, story synopsis, character list, character relationship network, plot branch nodes, and ending type. The level chain includes five required fields: level number, unlock condition, level objective, clue list, and time limit; The interactive event chain includes four required fields: event type, trigger condition, response action, and target node to jump to. Each input subset is identified by the corresponding primary key field prefix, and the prefix CAP of the complete capability combination dataset is mapped to the plot chain and the interactive event chain. The prefix ENC of the encrypted configuration parsing dataset is mapped to the level chain, and the prefix H5 of the corrected page text dataset is mapped to all links; The prefix PER of the hierarchical isolation permission dataset is mapped to the character field of the story chain, and the prefix MM of the entity fusion dataset is mapped to the interaction event chain; After forming a preliminary set of full-link fields, check whether the required fields of each link are complete. Missing fields are marked as missing link fields and assigned a unique missing link field number. Check whether the association mapping relationship between links is complete, mark disconnected associated links as disconnected associated links and assign a unique disconnected associated link number; All missing link field numbers and disconnected link numbers are summarized and encapsulated into a structurally complete tag; Collect the current script's full-link structured dataset, and simultaneously retrieve a single set of historical scripts' full-link structured datasets for the same script from the database; The latest generated link and file encrypted hash values ​​are extracted through the latest data field extraction process, and then encapsulated to generate the current script game full-link structured dataset; The historical version data extraction process extracts the links and encrypted hash values ​​of historical files, and encapsulates them to generate a structured dataset of the entire link of historical script games. Compare the overall file crypto hash values ​​of the current dataset with those of the historical datasets. Files with inconsistent crypto hash values ​​are marked as tampered hash mismatch indicators. Compare the content of each field in the current dataset with that in the historical dataset; preset a whitelist for the normal iteration range, which includes: plot fields in the plot chain, level fields in the level chain, and response action description fields in the interaction event chain; The plot fields include: story synopsis, character descriptions, and plot branch node descriptions; the level fields in the level chain include: level objectives and clue descriptions. When a field-by-field comparison reveals differences in the whitelist fields, these differences are marked as normal version evolution differences and are not written into the version security flag. When there are differences between fields outside the whitelist, they are marked as version conflict fields and assigned a unique version conflict field number; The hash mismatch identifier and all version conflict field numbers are summarized and encapsulated into a version security tag; Read all field numbers and identifiers from the structural integrity tag and the version security tag, and classify and summarize them according to two categories: data structure dimension and security version dimension. Assign a unique exception code to each exception. The classified anomaly codes are matched with the rule key-value table in the adjustment compensation mapping parameter set; The link field completion action is based on the link field completion compensation rules. It automatically completes the link-specific fields for the marked missing link field numbers, as well as the category-differentiated fields for the reasoning trick parameters and the real scene spatial coordinate parameters. The multi-link association binding action is based on the multi-link association binding adjustment rules. A two-way mapping relationship is established between the links based on the marked disconnected link number, and the linkage logic of clue unlocking, spatial point triggering and plot branch jump is bound. The data rollback operation is based on the data rollback compensation rules. When a tampered hash mismatch is detected, the corresponding untampered historical version snapshot is automatically retrieved for overwriting and rollback. The version conflict field isolation action is based on the version conflict field isolation adjustment rules. It automatically marks the conflicting plot and level fields for the marked version conflict field number, and outputs a conflict detail list for manual optimization decision-making. Conflicting fields are not merged to avoid mutual overwriting. Perform the summation and merging operations and the difference operation again on the corrected full-link dataset to generate structural integrity tags and version security tags again; Verify whether missing fields and broken links have been fully repaired and whether tampering flags have been cleared. If all criteria are met, the compensation is marked as successful. If the criteria are not met, a second compensation is triggered and the audit log is recorded. After successful verification, a complete script-based game full-chain structured dataset is generated, and a standardized JSON file is exported for direct deployment.

[0015] It should be noted that JSON is a fixed-format data exchange text specification; JSONPointer is used to accurately locate a unique single node in JSON; AES is the NIST official standard symmetric encryption algorithm; SHA-256 is the NIST standard one-way hash function; CRC-64 is a non-cryptographic verification algorithm; the original H5 page text is the native HTML plain text source code; OCR clue text is readable text recognized by OCR optical character recognition; and prefix CAP mapping, prefix ENC mapping, prefix MM mapping, and prefix H5 mapping are data classification prefix routing mapping rules.

[0016] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely illustrative of the principles of the invention. Various changes and modifications can be made to the invention without departing from its spirit and scope, and all such changes and modifications fall within the scope of the present invention as claimed. The scope of protection of the present invention is defined by the appended claims and their equivalents.

Claims

1. A large-model-driven automatic generation system for script game data structures, characterized in that, include: Configure the encryption module: Collect two types of original text from a single script and the mapping text from the matching template interface, generate a configuration compliance mark through dual dataset verification and comparison, generate a key authorization mark by combining AES-256 encryption, complete the compensation action by combining correction rules, and output a layered encrypted configuration file; The two types of original text for a single script are: basic information and gameplay rules information for the single script. The method for generating configuration compliance tags by dual dataset verification and comparison is as follows: traverse each field verification entry in the JSON specification verification result dataset, compare one by one whether the target field exists in the field mapping table of the front-end and back-end interface matching standard dataset, and summarize and encapsulate all abnormal field numbers and missing field numbers into configuration compliance tags. The dual datasets include: the JSON specification verification result dataset and the front-end and back-end interface matching standard dataset. The front-end and back-end interface matching standard dataset includes: the interface request field mapping table and the front-end template rendering field mapping table. Instruction adaptation module: Combines the decrypted data of the layered encrypted configuration file, collects single natural language instructions and single page source code, generates valid instruction tags, generates combined compatibility tags through full pairing verification of the capability matrix, and outputs the structured basic data of the script game after iterative correction; The method for generating a combination compatibility tag through full pairing verification of the capability matrix is ​​as follows: traverse each pairing unit in the matrix, and for each pairing combination, verify whether the trigger signal types in the execution constraints of the pairing combination are consistent, verify whether there are parameter conflicts with the same name in the fixed parameter set of the pairing combination, and verify whether there are circular dependencies in the execution order constraints of the pairing combination; pairing combinations that pass all checks are marked as compatible combinations, and pairing combinations that fail any check are marked as conflicting combinations; combinations with temporal conflicts are assigned a unique temporal conflict combination number, and combinations with missing dependencies are assigned a unique missing dependency capability number; all conflict numbers and missing numbers are summarized and encapsulated into a combination compatibility tag; Layered fusion module: Combines the structured basic data of script games, collects three-layer permission and multimodal material data, combines incremental differential data to generate local correlation verification markers, performs multi-dimensional compensation, splits and outputs layered subsets and generates entity fusion dataset and incrementally updated local dataset; Link verification module: Combining hierarchical subsets, entity fusion datasets and incrementally updated local datasets, it collects input subsets to generate structurally complete tags, generates version security tags by comparing old and new version hashes with fields, and generates a production-ready full-link structured dataset through closed-loop correction.

2. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for generating the key authorization marker is as follows: The encrypted hash value of the file and the integrity flag of the configuration field in the encrypted configuration file verification dataset are converted into the first binary sequence according to the preset encoding rule, and the authorized module identity and permission level in the module key access permission dataset are converted into the second binary sequence according to the same encoding rule. The encrypted configuration file verification dataset is obtained by extracting the SHA-256 file encryption hash value and CRC-64 configuration field integrity mark after configuring the segmented configuration using AES-256 encryption. The module key access permission dataset is formed by reading the system authorization configuration, extracting the authorized module identity, and encapsulating the private configuration access permission level. After aligning the lengths of the two sequences, perform an XOR operation bit by bit. Bits with a value of 1 in the result are marked as abnormal bits. Map the abnormal bits back to the corresponding data items bit by bit. Extract two types of correction and location information: file tampering flag bits and unauthorized access level flag bits, and encapsulate them as key authorization flags.

3. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for completing the compensation action by combining correction rules is as follows: Read all anomaly location numbers and tag bits from the configuration compliance tag and key authorization tag, classify and summarize them according to anomaly type, and assign a unique anomaly identifier code to each type of anomaly; match the anomaly identifier code with the preset rule key value table in the adjustment compensation mapping parameter set.

4. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for generating valid instruction markers is as follows: The configuration modification execution actions in the configuration semantic transformation parameter set are encoded into the first feature sequence according to the action type. The length of the bit string is equal to the total number of modifiable fields and each bit is arranged in the field index order. When there is a modification operation, the corresponding bit is 1 and otherwise 0. The configuration semantic conversion parameter set is formed by concatenating natural language instructions with configuration specification fields as prompt words into a large model, parsing and outputting JSON format configuration modification execution actions, and then encapsulating them. The source code syntax error markers in the page source code correction parameter set are encoded into a second feature sequence according to the error type. The length of the bit string is equal to the total number of verifiable syntax nodes and each bit is arranged in the parsing order of the syntax nodes. When an error marker exists, the corresponding bit is 1 and otherwise 0. The page source code correction parameter set is obtained by performing syntax verification and multi-terminal adaptation prediction on the single page source code by the large model, and extracting and encapsulating the source code syntax error markers. When the lengths of two sequences are inconsistent, the maximum value is taken for alignment and 0 is added to the high bits of the shorter sequence. After alignment, an XOR operation is performed bit by bit. Bits with a result of 1 are marked as abnormal points. Abnormal points are classified by dimension to extract two types of correction and positioning identifiers: configuration conflict points and page adaptation abnormal points. These are then encapsulated into instruction valid markers.

5. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for generating local correlation verification markers by combining incremental differential data is as follows: Iterate through all entities and associated edges in the unlayered original script configuration dataset, and compare them one by one to see if they fall within the scope of the host's exclusive field. Those that fall within the scope are marked as private entities and the corresponding cross-domain associated edges are marked as illegal associated edges and assigned a unique illegal cross-domain associated edge number. The collected local text before and after modification is separated into changed and unchanged content through comparison algorithms, generating a local dataset of changed fragments and an original local dataset of unchanged fragments. The entity set is compared to extract newly added and disappeared entities and marked as changed related entities. The set of related edges is compared to extract broken related edges and assigned a unique invalid related edge number. The total number of changed entities is divided by the total number of entities in the whole script to obtain the data volume ratio, and then multiplied by the benchmark computing power consumption value to obtain the estimated computing power occupation range. The invalid related edge numbers and computing power occupation range are summarized as local association verification marks.

6. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for performing multi-dimensional compensation is as follows: Read all the numbers and interval identifiers in the hierarchical permission marker, entity matching marker and local association verification marker, classify and summarize them according to the permission dimension, entity dimension and incremental dimension, assign a unique exception code to each exception, and match the exception code with the rule key value table in the adjustment compensation mapping parameter set; The hierarchical permission markers are obtained by traversing script entities, distinguishing between the host's private content and the player's visible content by linking edges, and summarizing illegal cross-domain linking edges and character IDs for clue imbalances. The entity matching markers are obtained by summarizing and encapsulating the matching deviation entities and missing real-world field entity numbers after the three-modal entity cosine similarity matching of text, image and spatial entities. The local association verification mark is encapsulated by summarizing the failed association edges and computing power occupancy intervals after incremental differential comparison.

7. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for generating structurally complete tags is as follows: Five sets of input sub-datasets were collected: complete capability combination dataset, encrypted configuration parsing dataset, corrected page text dataset, hierarchical isolation permission dataset, and entity fusion dataset. The corresponding link was identified according to the prefix of the primary key field. The prefix CAP of the complete capability combination dataset was mapped to the plot chain and interactive event chain, the prefix ENC of the encrypted configuration parsing dataset was mapped to the level chain, and the prefix H5 of the corrected page text dataset was mapped to all links. After forming a preliminary full-link field set, check the completeness of the required fields for each link. If any are missing, mark them as missing link fields and assign a unique missing link field number. Check the completeness of the association mapping between links. If any are disconnected, mark them as disconnected links and assign a unique disconnected link number. Summarize all missing link field numbers and disconnected link numbers and encapsulate them into a structurally complete tag.

8. The large-model-driven automatic generation system for script game data structures according to claim 1, characterized in that, The method for generating version security tags is as follows: Collect the current script's full-link structured dataset and extract the latest generated links and file encrypted hash values ​​to encapsulate it into the current dataset. Directly retrieve a single set of historical datasets for the same script in the database and extract the links and historical hash values ​​of the historical versions to encapsulate them into historical datasets. Compare the overall encrypted hash values ​​of the files; those that do not match are marked as tampered hash mismatches. Compare the content of each field in the current and historical datasets field by field. When there is a difference in the whitelisted fields, it is marked as a normal version evolution difference and is not written into the version security tag. When there is a difference in the fields outside the whitelist, it is marked as a version conflict field and assigned a unique version conflict field number. The tamper hash mismatch identifier and all version conflict field numbers are summarized and encapsulated into a version security tag.

Images