Intelligent auxiliary method, system and equipment for game development and medium

Abstract

The invention is applicable to the technical field of computers, and provides an intelligent auxiliary method for game development, which comprises the following steps: acquiring technical problem description and multi-modal data submitted by a developer, the multi-modal data comprising document data, code data or image audio data; analyzing the multi-modal data and the technical problem description, and performing cross-modal fusion to generate a multi-modal problem vector; based on the multi-modal problem vector, positioning a fundamental contradiction of a technical problem through a causal graph neural network, and generating a causal feature vector; based on the causal feature vector, performing technical problem matching in a pre-established technical knowledge base to obtain a universal template; according to the engine type of the technical problem, engine special layer data of the technical knowledge base is called, abstract logic in the general template is converted into engine logic capable of being executed by the engine type, and a solution is generated. And a more efficient, convenient and reliable solution generation mode is provided for developers.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to an intelligent assistance method, system, device, and medium for game development. Background Art

[0002] Game development is a core area of today's digital entertainment industry, and the use of game engines like Cocos Creator has become a mainstream trend. However, with the continuous innovation of gameplay and visual effects, developers face increasingly complex technical challenges.

[0003] In the existing technology, the construction of game development assistance systems mainly solves technical problems by integrating information from official documents and community forums. In the process of information collation, it relies on single text modal analysis, which makes it difficult to fully understand the multi-dimensional requirements of developers such as code, images, audio, etc. As a result, there are defects such as scattered information and uneven solution quality. It is difficult to provide developers with timely and accurate technical support. Especially when dealing with novel or complex development requirements, existing game development assistance systems are often unable to cope with the situation and cannot provide developers with personalized and high-quality solutions.

[0004] Therefore, there is an urgent need to build an intelligent game development assistance system to reduce the time for developers to solve technical problems. Summary of the Invention

[0005] The embodiments of the present application provide an intelligent assistance method, system, device and medium for game development, which can solve one of the above-mentioned problems in the prior art.

[0006] In a first aspect, an embodiment of the present application provides an intelligent assistance method for game development, comprising:

[0007] Obtaining a technical problem description and multimodal data submitted by a developer, wherein the multimodal data includes document data, code data, or image and audio data;

[0008] Parsing the multimodal data and the technical problem description, and performing cross-modal fusion to generate a multimodal problem vector;

[0009] Based on the multimodal problem vector, the fundamental contradiction of the technical problem is located through a causal graph neural network to generate a causal feature vector;

[0010] Based on the causal feature vector, matching technical issues in a pre-established technical knowledge base is performed to obtain a general template;

[0011] According to the engine type of the technical problem, the engine-specific layer data of the technical knowledge base is called to convert the abstract logic in the general template into engine logic executable by the engine type to generate a solution.

[0012] Furthermore, the parsing of the multimodal data and the technical problem description includes:

[0013] For document data, semantic analysis is performed based on the BERT model and combined with the knowledge graph in the game development field;

[0014] For code data, based on the abstract syntax tree, extract the API call chain and identify potential logic defects;

[0015] For image and audio data, the lightweight ViT model is used to extract UI layout features from image data, and the Wav2Vec 2.0 model is used to analyze audio data;

[0016] For technical problem descriptions, natural language processing technology is used to perform grammatical analysis, and the technical problem descriptions are classified to determine the problem labels.

[0017] Furthermore, the cross-modal fusion is performed to generate a multimodal question vector, including:

[0018] Through the cross-modal attention mechanism, the parsed text data, code data, image and audio data are mapped to a unified semantic space to generate a multimodal vector;

[0019] The multimodal vector is feature-concatenated with the technical problem description to generate a multimodal problem vector.

[0020] Furthermore, based on the multimodal problem vector, the fundamental contradiction of the technical problem is located through a causal graph neural network to generate a causal feature vector, including:

[0021] Inputting the multimodal question vector into a causal graph neural network, and generating a node feature representation for each node in the causal graph neural network;

[0022] Locate the node that has the greatest impact on the technical problem in the causal graph neural network and identify it as the root cause node;

[0023] Starting from the root cause node, traversing the causal neural network to generate multiple technical problem propagation paths;

[0024] Generating a confidence value for each technical problem propagation path based on the probability value of the root cause node and the weight value of the technical problem propagation path;

[0025] Among the multiple technical problem propagation paths, one or more technical problem propagation paths whose confidence values meet a preset threshold are selected and sequentially characterized to generate a causal feature vector.

[0026] Furthermore, locating the node that has the greatest impact on the technical problem in the causal graph neural network and determining it as the root cause node includes:

[0027] Based on the causal graph neural network, output an initial confidence value of each node;

[0028] The Softmax function is used to normalize the initial confidence value to obtain the probability value of each node;

[0029] The node with the largest probability value is determined as the root cause node.

[0030] Furthermore, the process of matching technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a general template includes:

[0031] Determining a root cause label of the technical problem based on the causal feature vector;

[0032] Retrieving a matching general template from a technical knowledge base based on the root cause label;

[0033] Among them, the technical knowledge base includes a general layer and an engine-specific layer. The general layer is used to store abstract general templates, and the engine-specific layer is used to store standardized expressions corresponding to engine types. The engine type is the game engine type to which the technical problem belongs.

[0034] Furthermore, according to the engine type of the technical problem, the engine-specific layer data of the technical knowledge base is called to convert the abstract logic in the general template into engine logic executable by the engine type to generate a solution, including:

[0035] Analyzing the multimodal data to determine the engine type of the technical problem;

[0036] Based on the engine type, obtaining engine-specific layer data from a technical knowledge base, the engine-specific layer data including an API mapping table and engine constraint rules;

[0037] Decomposing the general template into atomic steps and identifying abstract logic in the general template;

[0038] Mapping the abstract logic to the API mapping table, filling in parameters of a general template based on a pre-trained code generation model, and generating engine-specific code;

[0039] Based on the engine constraint rules, checking whether the engine-specific code complies with engine specifications;

[0040] The engine-specific code that complies with the engine specification is combined with the general template to generate a solution.

[0041] In a second aspect, an embodiment of the present application provides an intelligent assistance system for game development, including:

[0042] The first processing module is used to obtain the technical problem description and multimodal data submitted by the developer, wherein the multimodal data includes document data, code data, or image and audio data;

[0043] The second processing module is used to parse the multimodal data and the technical problem description, perform cross-modal fusion, and generate a multimodal problem vector;

[0044] A third processing module is configured to locate the fundamental contradiction of the technical problem based on the multimodal problem vector through a causal graph neural network and generate a causal feature vector;

[0045] A fourth processing module is configured to match technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a general template;

[0046] The fifth processing module is used to call the engine-specific layer data of the technical knowledge base according to the engine type of the technical problem, convert the abstract logic in the general template into engine logic executable by the engine type, and generate a solution.

[0047] In a third aspect, an embodiment of the present application provides a computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the intelligent assistance method for game development described above when executing the computer program.

[0048] In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, comprising a computer-readable storage medium storing a computer program, wherein the computer program implements the above-mentioned intelligent assistance method for game development when executed by a processor.

[0049] Compared with the prior art, the embodiments of the present application have the following beneficial effects:

[0050] The present application provides an intelligent assistance method for game development, which integrates multimodal data with the developer's description of the technical problem, making the understanding of the technical problem more three-dimensional and in-depth, reducing the inaccurate problem location caused by missing information or misunderstanding, and at the same time locating the fundamental contradiction of the technical problem through the causal graph neural network, which can quickly and accurately identify the core of the technical problem, further improving the efficiency and accuracy of technical problem location. The introduction of the technical knowledge base enables the present application to adapt to the code generation of mainstream game engines such as Unity, Unreal, Cocos Creator, and thus better solve the development problems encountered by developers during the development process, and enhance the adaptability and executability of the solution. BRIEF DESCRIPTION OF THE DRAWINGS

[0051] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the embodiments or descriptions of the prior art. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0052] Figure 1 This is a flowchart of an intelligent assistance method for game development provided by one embodiment of the present invention;

[0053] Figure 2 This is a schematic diagram of the structure of an intelligent assistance system for game development provided by one embodiment of the present invention;

[0054] Figure 3 It is a structural diagram of a computer device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0055] In the following description, specific details such as specific system structures and techniques are provided for purposes of illustration rather than limitation to facilitate a thorough understanding of the embodiments of the present application. However, it will be apparent to those skilled in the art that the present application may be implemented in other embodiments without these specific details. In other cases, detailed descriptions of well-known systems, devices, circuits, and methods are omitted to avoid obscuring the description of the present application with unnecessary detail.

[0056] It should be understood that when used in the present specification and the appended claims, the term "comprising" indicates the presence of described features, integers, steps, operations, elements and / or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or collections thereof.

[0057] It will also be understood that the term "and / or" used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.

[0058] As used in this specification and the appended claims, the term "if" can be interpreted as "when" or "upon" or "in response to determining" or "in response to detecting," depending on the context. Similarly, the phrase "if it is determined" or "if [described condition or event] is detected" can be interpreted as meaning "upon determination" or "in response to determining" or "upon detection of [described condition or event]" or "in response to detecting [described condition or event]," depending on the context.

[0059] In addition, in the description of the present application specification and the appended claims, the terms "first", "second", "third", etc. are only used to distinguish the descriptions and cannot be understood as indicating or implying relative importance.

[0060] References to "one embodiment" or "some embodiments" in this specification mean that a particular feature, structure, or characteristic described in conjunction with that embodiment is included in one or more embodiments of the present application. Thus, phrases such as "in one embodiment," "in some embodiments," "in other embodiments," and "in other embodiments" appearing in various places in this specification do not necessarily refer to the same embodiment, but rather mean "one or more but not all embodiments," unless otherwise specifically emphasized. The terms "including," "comprising," "having," and variations thereof all mean "including but not limited to," unless otherwise specifically emphasized.

[0061] See also Figure 1 As shown, the present invention is an intelligent auxiliary method for game development, comprising the following steps:

[0062] S100: Obtain a technical problem description and multimodal data submitted by a developer, wherein the multimodal data includes document data, code data, or image and audio data;

[0063] In this embodiment, the combined use of multimodal data can provide a more comprehensive understanding of the developer's technical problems, thereby more accurately locating the cause of the problem and providing more targeted auxiliary suggestions or solutions. Furthermore, an intelligent assistance method for game development of the present application is encapsulated into an AI assistance platform to provide developers with an interactive interface. Developers can input corresponding technical problem descriptions and upload multimodal data related to the technical problem through the interactive interface. Among them, multimodal data includes document data, code data or image and audio data. Document data specifically includes game engine log files, art resource configuration tables, level design documents, etc.; code data specifically includes problem-related script code snippets or version control information, etc.; image and audio data generally involve game runtime screenshots, character animation videos, sound effect files and player interaction heat maps, etc.

[0064] S200: parsing the multimodal data and the technical problem description, performing cross-modal fusion, and generating a multimodal problem vector;

[0065] In this application, by integrating multimodal data with the developer's description of the technical problem, the understanding of the technical problem is made more three-dimensional and in-depth, reducing the inaccurate problem location caused by missing information or misunderstanding.

[0066] In some embodiments, parsing the multimodal data and the technical problem description includes:

[0067] For document data, semantic analysis is performed based on the BERT model and combined with the knowledge graph in the game development field;

[0068] For code data, based on the abstract syntax tree, extract the API call chain and identify potential logic defects;

[0069] For image and audio data, the lightweight ViT model is used to extract UI layout features from image data, and the Wav2Vec 2.0 model is used to analyze audio data;

[0070] For technical problem descriptions, natural language processing technology is used to perform grammatical analysis, and the technical problem descriptions are classified to determine the problem labels.

[0071] In this embodiment, the document data is cleaned to remove irrelevant information, noise data and format errors to ensure the accuracy and consistency of the data. Then, natural language processing technology is used to perform word segmentation on the cleaned text, and the word segmentation results are converted into document vector representations. According to the characteristics and needs of the game development field, suitable prompt words are designed. The setting of prompt words can guide the BERT model to better understand the context and semantics of the document data. At the same time, the prompt-tuning technology is used to fine-tune the BERT model, such as optimizing prompt words and model parameters, so that the BERT model can better adapt to the document data parsing task in the game development field. In addition, according to the knowledge system and structure of the game development field, a domain knowledge graph is constructed. It can be understood that the domain knowledge graph should include elements such as entities, relationships, and attributes to fully reflect the knowledge system of the game development field. Then, the constructed knowledge graph is integrated with the BERT model. Specifically, in the process of BERT model parsing document data, the knowledge graph is used to provide additional contextual information and semantic constraints to improve the BERT model's understanding and analysis capabilities of the document content. At the same time, through the analysis of the document content, the technical field targeted by the technical problem and the corresponding engine type can be further determined.

[0072] In this embodiment, the uploaded code data is parsed and converted into an intermediate representation that can be processed by a computer. The parsed code is converted into an abstract syntax tree using compiler front-end technology. Each node in the abstract syntax tree represents a construct in the code, such as a variable declaration, function definition, or API call. The abstract syntax tree is traversed using algorithms such as depth-first search or breadth-first search. During the traversal, nodes representing API calls are identified. Through these nodes, specific identifiers in the code, such as function names and method names, can be obtained. Starting from the API call node, the call path is traced upward until the call starting point is found. All nodes on this path are connected in series to form an API call chain. The extracted API call chain is analyzed to check for potential logical defects. Specifically, static analysis techniques such as data flow analysis and control flow analysis are combined to conduct a more in-depth analysis of the API call chain to discover potential logical defects and provide a data foundation for subsequent technical problem analysis.

[0073] In this embodiment, for image data, the image data is loaded through the image processing library, and its size and format are adjusted. The image is subjected to data enhancement operations such as rotation, scaling, and cropping. The image is divided into several small blocks, and each block is projected into the embedding space using a linear layer to obtain a block-by-block image representation. When constructing a lightweight ViT model, it is necessary to select a model suitable for UI layout feature extraction, such as MobileViT, ExMobileViT, etc., and adjust the model parameter settings according to the specific task and training data set, such as the learning rate, batch size, number of training rounds, etc. The self-attention mechanism in the ViT model is used to capture the long-distance dependency between the block-by-block image representations, extract the UI layout features, and aggregate the image block features through global average pooling to obtain the UI layout feature representation of the entire image.

[0074] In this embodiment, the audio data is loaded through the audio processing library and adjusted to a unified sampling rate and format. The audio data is denoised and analyzed based on the Wav2Vec 2.0 model. When constructing the Wav2Vec 2.0 model, a model suitable for audio data analysis needs to be selected, and the model parameter settings, such as learning rate, batch size, number of training rounds, etc., need to be adjusted according to the specific task and training data set. Then, the denoised audio is encoded into a frame feature sequence based on the convolutional network in the Wav2Vec 2.0 model, and each frame feature is converted into a discrete feature through a vector quantization module. The encoded audio features are input into the Transformer model to learn the contextual representation of the audio features. The learned contextual representation is used for audio analysis, such as speech recognition, audio classification, etc., to obtain the correlation between the corresponding audio and the technical problem.

[0075] In this embodiment, after obtaining the text describing the technical problem, the text is preprocessed, such as removing special characters and redundant spaces. Based on the preprocessed text, Jieba word segmentation is used to perform Chinese word segmentation to obtain a word sequence. For the word sequence, the part of speech is marked for each word using HanLP. A grammatical structure tree of the text is constructed using Stanford Parser. Core grammatical components such as subject, predicate, and object are extracted from the grammatical structure tree. The main semantic relationships of the text are identified. Based on word frequency statistics and a preset part-of-speech weight table, the importance score of each word is calculated. Keywords are screened out, and Word2Vec is used to cluster the keywords to determine the problem labels of the technical problems. The technical problems raised by developers can be classified through the problem labels, and the relevant technical problems are then stored in the technical knowledge base in the form of problem labels to expand and improve the knowledge of the technical knowledge base.

[0076] In some possible embodiments, problem tags include performance issues, functional issues, compatibility issues, and security vulnerabilities. The keywords for performance issues may be frame rate drop, memory leak, high CPU / GPU load, etc. The keywords for functional issues may be character movement lag, UI element misalignment, sound effect asynchrony, graphics rendering, etc. The keywords for compatibility issues may be cross-engine adaptation failure, device-specific crash, and the keywords for security vulnerabilities may be code injection risk, unreleased resources, etc.

[0077] It is understandable that the data in multimodal data is received and stored based on the developer's active upload. In actual application, if the developer does not upload a certain type of data, such as text data, code data, or image and audio data, there is no need to analyze or process it. By analyzing multimodal data, we can preliminarily determine technical features related to technical problems, such as engine type, code defects, image anomalies, etc., thereby improving the accuracy of subsequent analysis of technical problems.

[0078] In some embodiments, performing cross-modal fusion to generate a multimodal question vector includes:

[0079] Through the cross-modal attention mechanism, the parsed text data, code data, image and audio data are mapped to a unified semantic space to generate a multimodal vector;

[0080] The multimodal vector is feature-concatenated with the technical problem description to generate a multimodal problem vector.

[0081] In this embodiment, the document data parsed by the BERT model is represented as a semantic vector, the extracted API call chain is converted into a graph embedding, the extracted UI layout features are represented as visual features, and the audio data analyzed by the Wav2Vec 2.0 model is represented as acoustic features. The semantic spaces of different modalities are aligned through a cross-modal attention mechanism to generate a unified multimodal feature representation, i.e., a multimodal vector. At the same time, the multimodal vector is feature-concatenated with the keywords in the technical problem description to form a multimodal problem vector. It can be understood that the keywords in the technical problem description can be represented as semantic vectors, and then feature-associated with each modal data in the multimodal vector, so that the multimodal problem vector contains both the information of the multimodal data and the information of the problem label, which is used for subsequent root cause analysis of the technical problem, thereby improving the accuracy of subsequent analysis of the technical problem.

[0082] Specifically, a developer named Zhang San submitted the following data through the aforementioned AI-assisted platform:

[0083] Technical Problem Description: "I need to create a water surface effect that ripples dynamically when the character moves."

[0084] Code data: / / Character movement control script (Cocos Creator)

[0085]

[0086] Image data: a static water surface map and a reference rendering. The static water surface map shows the initial water surface state, and the reference rendering shows the desired ripple diffusion pattern.

[0087] By analyzing the above technical problem description, it can be determined that the keywords of the core needs of developer Zhang San are "water surface fluctuations", "character movement" and "dynamic effects". The above keywords are used to determine that the technical problem description is a functional problem. For the code data, after analysis, it is determined that the technical feature of the current code is character position modification, which is associated with "character movement". At the same time, the code data is associated with "water surface fluctuations" and "dynamic effects", and it is determined that the water surface deformation logic is not triggered in the above code data, that is, there is a lack of call to the interactive interface. In addition, through the analysis of the image data, the corresponding image features are generated, and the keywords "water surface fluctuations" and "dynamic effects" are associated with the image features, and identified as water surface dynamic fluctuation effects. Therefore, the above character position modification, lack of call to the interactive interface and water surface dynamic fluctuation effects are multimodal problem vectors.

[0088] S300, based on the multimodal problem vector, locate the fundamental contradiction of the technical problem through a causal graph neural network and generate a causal feature vector;

[0089] In this application, by locating the fundamental contradictions of technical problems through the causal graph neural network, the core of the technical problem can be identified quickly and accurately, further improving the efficiency and accuracy of locating technical problems.

[0090] In some embodiments, step S300 includes:

[0091] Inputting the multimodal question vector into a causal graph neural network, and generating a node feature representation for each node in the causal graph neural network;

[0092] Locate the node that has the greatest impact on the technical problem in the causal graph neural network and identify it as the root cause node;

[0093] Starting from the root cause node, traversing the causal neural network to generate multiple technical problem propagation paths;

[0094] Generating a confidence value for each technical problem propagation path based on the probability value of the root cause node and the weight value of the technical problem propagation path;

[0095] A technical problem propagation path with the highest confidence value among the multiple technical problem propagation paths is characterized to generate a causal feature vector.

[0096] In this embodiment, the construction of a causal graph neural network typically includes technical entity nodes and event nodes, with edges representing the causal dependencies between nodes. Technical entity nodes include code variables, hardware indicators, functional modules, etc., while event nodes typically include abnormal events such as "stuttering" and "crashing." For example, in the technical issue described above by developer Zhang San, technical entity nodes include character position modification and missing calls to interactive interfaces, while event nodes represent non-volatile effects. It can be understood that the node feature representation is a vectorized description of each node in the causal graph, typically including technical entity attributes and contextual information, such as memory usage, API call frequency, and error log keywords.

[0097] In this embodiment, based on multiple nodes in the causal graph neural network, it is necessary to determine the node that has the greatest impact on the technical problem, and perform analysis based on the node, which helps to quickly locate the core of the problem, thereby greatly improving the efficiency of problem solving. At the same time, it can more accurately reveal the nature and cause of the problem, providing a solid foundation for formulating effective solutions.

[0098] It is understandable that when the technical problem is more complex, there are multiple possibilities for the technical problem propagation path that is ultimately generated. Therefore, in this embodiment, by determining the confidence value of each technical problem propagation path, the necessity of further analysis and processing of the technical problem propagation path is determined, avoiding indiscriminate analysis of all paths, thereby improving analysis efficiency and reducing unnecessary resource waste. Specifically, when the generated confidence value is greater than or equal to the preset threshold, it is determined that the propagation probability of the technical problem propagation path is high and further analysis is required. Therefore, it is characterized and a causal feature vector is generated, wherein the causal feature vector includes the root cause node, the technical problem propagation path, and the confidence value corresponding to the technical problem propagation path.

[0099] In this embodiment, the confidence value of each technical problem propagation path is calculated using a weighted average method, which is calculated by taking a weighted average of the probability value of the root cause node and the weight value of the corresponding technical problem propagation path. The weight value of the technical problem propagation path is calculated by multiplying the weights of each edge. In one possible embodiment, if there is a technical problem propagation path: The total path weight is 0.8×0.9=0.72.

[0100] In some embodiments, locating the node that has the greatest impact on the technical problem in the causal graph neural network and determining it as the root cause node includes:

[0101] Based on the causal graph neural network, output an initial confidence value of each node;

[0102] The Softmax function is used to normalize the initial confidence value to obtain the probability value of each node;

[0103] The node with the largest probability value is determined as the root cause node.

[0104] In this application, the causal graph neural network includes a graph convolution layer and a fully connected layer. By inputting the multimodal problem vector into the causal graph neural network, the node feature representation of each node is generated through the graph convolution layer, and then the node feature representation is input into the fully connected layer, and the initial confidence value of each node is output. It can be understood that the fully connected layer is located at the end of the causal graph neural network and is used to calculate the initial confidence value of each node. The specific calculation formula is z i =W fc ·h i +b, where W fc represents the weight matrix, b represents the bias vector, h i Represents the node feature representation of the i-th node. Further, each initial confidence value is normalized in turn by the Softmax function to obtain the probability value of each node. The calculation formula of the Softmax function is

[0105] In this embodiment, the node with the largest probability value is determined as the root cause node. In some other possible embodiments, if the technical problem is more complex, several nodes with higher probability values can be determined as root cause nodes as needed and analyzed in sequence.

[0106] S400, matching technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a general template;

[0107] In this embodiment, the introduction of the technical knowledge base enables this application to adapt to the code generation of mainstream game engines such as Unity, Unreal, CocosCreator, etc., thereby better solving development problems encountered by developers during the development process and enhancing the adaptability and executability of the solution.

[0108] In some embodiments, step S400 includes:

[0109] Determining a root cause label of the technical problem based on the causal feature vector;

[0110] Retrieving a matching general template from a technical knowledge base based on the root cause label;

[0111] Among them, the technical knowledge base includes a general layer and an engine-specific layer. The general layer is used to store abstract general templates, and the engine-specific layer is used to store standardized expressions corresponding to engine types. The engine type is the game engine type to which the technical problem belongs.

[0112] In this embodiment, the technical knowledge base stores a large number of solutions to basic technical problems to deal with routine technical problems and improve efficiency. In addition, the technical problem descriptions and corresponding solutions submitted by developers are stored in the technical knowledge base, and the technical knowledge base is technically expanded. Specifically, based on the problem labels corresponding to the technical problem descriptions, the relevant technical problems are classified into corresponding label categories in the technical knowledge base, and the relevant multimodal data and solutions to the technical problems are recorded. For the solutions to the technical problems, the engine logic related to the game engine type to which the technical problems belong is abstracted, and then the corresponding general templates are generated. At the same time, the correlation is matched with the existing general templates in the technical knowledge base. For unrelated general templates, they are expanded into the technical knowledge base, and the engine logic of their solutions is standardized and stored in the engine-specific layer of the technical knowledge base. For related general templates, they are stored under the corresponding general template category, thereby expanding the cases of the technical knowledge base.

[0113] Specifically, when searching and matching the technical knowledge base, the correlation between the root cause label of the technical problem and the general template in the technical knowledge base is analyzed, and the corresponding general template is called from the technical knowledge base to generate a solution, thereby improving the assistance efficiency of the AI-assisted platform.

[0114] As can be understood, specifically, the technical knowledge base includes a general layer and an engine-specific layer. The general layer is used to store common templates across engines, that is, to abstract the solutions and generate common templates, while the engine-specific layer is used to record the API differences and best practices of each engine type, that is, to store standardized solutions corresponding to the engine type.

[0115] In this embodiment, the engine type is the game engine type used by the developer when developing the game, specifically the game engine type targeted by the technical problem raised by the developer. Specifically, the engine types include Unity, UnrealEngine, Cocos Creator, etc.

[0116] S500: Based on the engine type of the technical problem, call the engine-specific layer data of the technical knowledge base, convert the abstract logic in the general template into engine logic executable by the engine type, and generate a solution.

[0117] In some embodiments, step S500 includes:

[0118] Analyzing the multimodal data to determine the engine type of the technical problem;

[0119] Based on the engine type, obtaining engine-specific layer data from a technical knowledge base, the engine-specific layer data including an API mapping table and engine constraint rules;

[0120] Decomposing the general template into atomic steps and identifying abstract logic in the general template;

[0121] Mapping the abstract logic to the API mapping table, filling in parameters of a general template based on a pre-trained code generation model, and generating engine-specific code;

[0122] Based on the engine constraint rules, checking whether the engine-specific code complies with engine specifications;

[0123] The engine-specific code that complies with the engine specification is combined with the general template to generate a solution.

[0124] In this embodiment, the multimodal data uploaded by the developer can be used to analyze the engine type corresponding to the technical problem. Specifically, in the code data, the code data is analyzed to determine whether there are API calls specific to each engine type, such as Unity's GameObject or Unreal's AActor. If the document data uploaded by the developer is an error log, it can also be analyzed by analyzing the error prompts in the error log, such as Unity's NullReferenceException. For image and audio data, it can also be determined by analyzing the UI layout features in the image data to determine whether there are UI components specific to each engine type in its UI layout. In addition, it can also be determined by analyzing the description of the technical problem uploaded by the developer. If the technical problem description exists or the multimodal data cannot determine the corresponding engine type, then when generating a solution, multiple solutions are generated for the developer's technical problem to match multiple engine types to meet the developer's requirements.

[0125] It can be understood that the engine-specific layer also stores API mapping tables and engine constraint rules for each engine type, which are used to transform solutions to technical problems from general templates to engine-specific logic. Specifically, the API mapping table is used to store the correspondence between abstract logic in general templates and engine type APIs, such as the correspondence between "physical force application" and Unity's Rigidbody.AddForce() and Unreal's UPrimitiveComponent::AddForce(), etc., while the engine constraint rules store syntax specifications, performance restrictions, etc., which are used to ensure that the final generated engine-specific code complies with the corresponding engine rules.

[0126] In this embodiment, the conversion between the general template and the engine logic requires first decomposing the general template, and then identifying its abstract logic, and finally generating the engine-specific code by calling the engine-specific layer data. Specifically, taking the technical problem of the developer Zhang San as an example, the root cause label is "dynamic fluctuation effect of the water surface". Based on the root cause label, matching is performed from the technical knowledge base to obtain the general template "dynamic water surface effect implementation", and the code in the calling template is decomposed into the following atomic steps: ① Use vertex shader to modify the water surface mesh deformation, ② Calculate the fluctuation center according to the character position, ③ Update the shader parameters in real time. In addition, through the annotation content in the code data submitted by Zhang San, it can be analyzed that the engine type corresponding to Zhang San's technical problem is Cocos Creator, at this time calls the CocosCreator engine API related to vertex shader in the engine-specific layer, such as cc.Material, cc.renderer.device.createShader, etc., and then based on the code generation model, fills in specific API parameters according to the context of the code in the general template, generates engine-specific code, and analyzes the generated engine-specific code through engine constraint rules to determine whether it complies with the engine specifications. Finally, the engine-specific code is merged with the general template to generate a solution. In some embodiments, the solution also includes engine parameter adjustment suggestions, etc.

[0127] See also Figure 2 As shown, the present invention also provides an intelligent assistance system for game development, the system comprising:

[0128] The first processing module 201 is used to obtain a technical problem description and multimodal data submitted by a developer, wherein the multimodal data includes document data, code data, or image and audio data;

[0129] The second processing module 202 is configured to parse the multimodal data and the technical problem description, perform cross-modal fusion, and generate a multimodal problem vector;

[0130] The third processing module 203 is configured to locate the fundamental contradiction of the technical problem through a causal graph neural network based on the multimodal problem vector and generate a causal feature vector;

[0131] The fourth processing module 204 is configured to match technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a general template;

[0132] The fifth processing module 205 is used to call the engine-specific layer data of the technical knowledge base according to the engine type of the technical problem, convert the abstract logic in the general template into engine logic executable by the engine type, and generate a solution.

[0133] It is understandable that if Figure 1 The contents of the embodiment of the intelligent assistance method for game development shown in the figure are applicable to the embodiment of the intelligent assistance system for game development. The functions specifically implemented by the embodiment of the intelligent assistance system for game development are similar to those in the embodiment of the figure. Figure 1 The embodiment of the intelligent auxiliary method for game development shown in FIG. 1 is the same as that shown in FIG. 1 , and the beneficial effects achieved are the same as those achieved in FIG. Figure 1 The beneficial effects achieved by the embodiment of the intelligent assistance method for game development shown are also the same.

[0134] It should be noted that the information interaction, execution process and other contents between the above-mentioned systems are based on the same concept as the embodiment of the method of the present invention. Their specific functions and technical effects can be found in the method embodiment part and will not be repeated here.

[0135] Those skilled in the art can clearly understand that, for the convenience and brevity of description, only the division of the above-mentioned functional units and modules is used as an example for illustration. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiment can be integrated into one processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the scope of protection of this application. The specific working process of the units and modules in the above-mentioned system can refer to the corresponding process in the aforementioned method embodiment, and will not be repeated here.

[0136] See also Figure 3 As shown, an embodiment of the present invention further provides a computer device 3, comprising: a memory 302 and a processor 301 and a computer program 303 stored on the memory 302. When the computer program 303 is executed on the processor 301, an intelligent auxiliary method for game development as described in any one of the above methods is implemented.

[0137] The computer device 3 may be a desktop computer, a notebook computer, a PDA, a cloud server or other computing devices. The computer device 3 may include, but is not limited to, a processor 301 and a memory 302. Those skilled in the art will understand that Figure 3 This is merely an example of the computer device 3 and does not constitute a limitation on the computer device 3 . The computer device 3 may include more or fewer components than shown in the figure, or a combination of certain components, or different components. For example, the computer device 3 may also include input and output devices, network access devices, etc.

[0138] The processor 301 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor may be a microprocessor or any conventional processor.

[0139] In some embodiments, the memory 302 may be an internal storage unit of the computer device 3, such as a hard disk or memory of the computer device 3. In other embodiments, the memory 302 may also be an external storage device of the computer device 3, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) card, a Flash Card, etc. equipped on the computer device 3. Furthermore, the memory 302 may include both an internal storage unit of the computer device 3 and an external storage device. The memory 302 is used to store an operating system, application programs, a boot loader, data, and other programs, such as the program code of the computer program. The memory 302 may also be used to temporarily store data that has been output or is about to be output.

[0140] An embodiment of the present invention further provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the intelligent auxiliary method for game development as described in any one of the above methods is implemented.

[0141] In this embodiment, if the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the present application implements all or part of the process in the above-mentioned embodiment method by instructing the relevant hardware through a computer program. The computer program can be stored in a computer-readable storage medium. When the computer program is executed by a processor, it can implement the steps of each of the above-mentioned method embodiments. The computer program includes computer program code, which can be in source code form, object code form, executable file or some intermediate form. The computer-readable medium can at least include: any entity or device capable of carrying computer program code to a camera / computer device, a recording medium, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electric carrier signal, a telecommunication signal, and a software distribution medium. For example, a USB flash drive, a mobile hard drive, a magnetic disk or an optical disk. In some jurisdictions, according to legislation and patent practice, computer-readable media cannot be electric carrier signals or telecommunication signals.

[0142] The above-described embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present application, and should all be included in the scope of protection of the present application.

Claims

1. An intelligent auxiliary method for game development, characterized in that: include: Obtaining a technical problem description and multimodal data submitted by a developer, wherein the multimodal data includes document data, code data, or image and audio data; Parsing the multimodal data and the technical problem description, and performing cross-modal fusion to generate a multimodal problem vector; Based on the multimodal problem vector, the fundamental contradiction of the technical problem is located through a causal graph neural network to generate a causal feature vector; Based on the causal feature vector, matching technical issues in a pre-established technical knowledge base is performed to obtain a general template; According to the engine type of the technical problem, the engine-specific layer data of the technical knowledge base is called to convert the abstract logic in the general template into engine logic executable by the engine type to generate a solution.

2. The method according to claim 1, wherein The parsing of the multimodal data and the technical problem description includes: For document data, semantic analysis is performed based on the BERT model and combined with the knowledge graph in the game development field; For code data, based on the abstract syntax tree, extract the API call chain and identify potential logic defects; For image and audio data, the lightweight ViT model is used to extract UI layout features in image data, and the Wav2Vec2.0 model is used to analyze audio data; For technical problem descriptions, natural language processing technology is used to perform grammatical analysis, and the technical problem descriptions are classified to determine the problem labels.

3. The method according to claim 2, wherein The cross-modal fusion is performed to generate a multimodal question vector, including: Through the cross-modal attention mechanism, the parsed text data, code data, image and audio data are mapped to a unified semantic space to generate a multimodal vector; The multimodal vector is feature-concatenated with the technical problem description to generate a multimodal problem vector.

4. The method according to claim 1, wherein Based on the multimodal problem vector, locating the fundamental contradiction of the technical problem through a causal graph neural network and generating a causal feature vector include: Inputting the multimodal question vector into a causal graph neural network, and generating a node feature representation for each node in the causal graph neural network; Locate the node that has the greatest impact on the technical problem in the causal graph neural network and identify it as the root cause node; Starting from the root cause node, traversing the causal neural network to generate multiple technical problem propagation paths; Generating a confidence value for each technical problem propagation path based on the probability value of the root cause node and the weight value of the technical problem propagation path; Among the multiple technical problem propagation paths, one or more technical problem propagation paths whose confidence values meet a preset threshold are selected and sequentially characterized to generate a causal feature vector.

5. The method according to claim 4, wherein The step of locating the node that has the greatest impact on the technical problem in the causal graph neural network and determining it as the root cause node includes: Based on the causal graph neural network, output an initial confidence value of each node; The Softmax function is used to normalize the initial confidence value to obtain the probability value of each node; The node with the largest probability value is determined as the root cause node.

6. The method according to claim 1, wherein The method of matching technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a universal template includes: Determining a root cause label of the technical problem based on the causal feature vector; Retrieving a matching general template from a technical knowledge base based on the root cause label; Among them, the technical knowledge base includes a general layer and an engine-specific layer. The general layer is used to store abstract general templates, and the engine-specific layer is used to store standardized expressions corresponding to engine types. The engine type is the game engine type to which the technical problem belongs.

7. The method according to claim 6, wherein The method of calling the engine-specific layer data of the technical knowledge base according to the engine type of the technical problem, converting the abstract logic in the general template into engine logic executable by the engine type, and generating a solution includes: Analyzing the multimodal data to determine the engine type of the technical problem; Based on the engine type, obtaining engine-specific layer data from a technical knowledge base, the engine-specific layer data including an API mapping table and engine constraint rules; Decomposing the general template into atomic steps and identifying abstract logic in the general template; Mapping the abstract logic to the API mapping table, filling in parameters of a general template based on a pre-trained code generation model, and generating engine-specific code; Based on the engine constraint rules, checking whether the engine-specific code complies with engine specifications; The engine-specific code that complies with the engine specification is combined with the general template to generate a solution.

8. An intelligent auxiliary system for game development, characterized in that: include: The first processing module is used to obtain the technical problem description and multimodal data submitted by the developer, wherein the multimodal data includes document data, code data, or image and audio data; The second processing module is used to parse the multimodal data and the technical problem description, perform cross-modal fusion, and generate a multimodal problem vector; A third processing module is configured to locate the fundamental contradiction of the technical problem based on the multimodal problem vector through a causal graph neural network and generate a causal feature vector; A fourth processing module is configured to match technical issues in a pre-established technical knowledge base based on the causal feature vector to obtain a general template; The fifth processing module is used to call the engine-specific layer data of the technical knowledge base according to the engine type of the technical problem, convert the abstract logic in the general template into engine logic executable by the engine type, and generate a solution.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the method according to any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

Images