Animation keel real-time debugging method and device, storage medium and equipment

Abstract

The invention provides an animation keel real-time debugging method and device, a storage medium and equipment. The animation keel real-time debugging method comprises the steps of obtaining an animation keel sent by a first terminal and a first skeleton replacement file sent by a second terminal; extracting a first interface mark from the first skeleton replacement file; traversing all interface marks contained in the animation keel, and determining a second interface mark matched with the first interface mark; covering the first skeleton replacement file to a skeleton code part corresponding to the second interface mark to obtain a debugged animation keel; sending the debugged animation keel to the first terminal; and after debugging confirmation information fed back by the first terminal is received, issuing the debugged animation keel. The debugging efficiency of different function ends on the same animation keel is improved by receiving the debugging of different function ends on the local skeleton of the animation keel at the engine end.

Description

Technical Field

[0001] The invention relates to the field of animation, and in particular to a method, a device, a storage medium and equipment for real-time debugging of an animation keel. Background Art

[0002] DragonBone Animation is a 2D game animation platform for designers, providing solutions for 2D skeletal animation. In the prior art, DragonBone Animation can only view static animation models, but not animation effects. If you want to modify the data of a certain bone in the animation keel, you need to re-import the keel file to view it.

[0003] In the prior art, designers or artists usually generate keel files in the form of pictures. When programmers need to debug the animation keel, they not only need to compile the keel file into a code file, but also need to import all the keel data. As a result, the animation keel debugging process requires both artists and programmers to spend a long time. In addition, due to the large difference in the functions of both parties, all debugged keel files are constantly loaded during the animation keel debugging process, resulting in time-consuming communication and low collaboration efficiency. Summary of the invention

[0004] Based on this, the present invention provides a real-time debugging method, device, storage medium and equipment for animation keels. By receiving the debugging of local skeletons of animation keels by different functional ends at the engine end, the situation in which different functional ends need to load all animation keels for each debugging is reduced, and real-time debugging and reading of animation keels are achieved, thereby improving the debugging communication efficiency of different functional ends on the same animation keel.

[0005] In a first aspect, the present invention provides a method for real-time debugging of an animation keel, comprising:

[0006] Obtain the animation keel sent by the first terminal and the first skeleton replacement file sent by the second terminal;

[0007] extracting a first interface marker from the first bone replacement file;

[0008] Traversing all interface marks included in the animation keel, and determining a second interface mark that matches the first interface mark;

[0009] Overwrite the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain the debugged animation keel;

[0010] Sending the debugged animation keel to the first terminal;

[0011] After receiving the debugging confirmation information fed back by the first terminal, the debugged animation keel is released.

[0012] Furthermore, the animation keel sent by the first terminal is a JSON file;

[0013] The animation keel file is converted into a compiled file in the same format as the first skeleton replacement file.

[0014] Furthermore, before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark, the following steps are also included:

[0015] If the second interface mark includes a file non-debuggable tag, sending skeleton code non-debuggable information and the skeleton part corresponding to the second interface mark to the first terminal and / or the second terminal;

[0016] If the second interface mark includes a file debuggable tag, a bone replacement request is sent to the second terminal. After receiving the bone replacement confirmation information sent by the second terminal, the first bone replacement file is overwritten to the bone code part corresponding to the second interface mark.

[0017] Furthermore, before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark, the following steps are also included:

[0018] Compare the skeleton code corresponding to the second interface mark with the first skeleton replacement file;

[0019] If the skeleton code is the same as the first skeleton replacement file, a skeleton replacement code verification message is sent to the second terminal.

[0020] Furthermore, the animation keel real-time debugging method also includes:

[0021] If the similarity between the skeleton code and the first skeleton replacement file is lower than a first threshold, a skeleton replacement code verification message is sent to the second terminal.

[0022] Furthermore, sending the debugged animation keel to the first terminal is specifically:

[0023] Convert the debugged animation keel into a set of JSON files and texture sets;

[0024] The set of the JSON file and the texture set, and a post-debugging confirmation request are sent to the first terminal.

[0025] Furthermore, the animation keel real-time debugging method also includes:

[0026] Determine whether the animation keel also includes the same type of bone part information according to the bone part information marked by the second interface;

[0027] If the animation keel also includes the same type of bone part information, obtaining the third interface mark corresponding to the same type of bone part information;

[0028] Sending a skeleton code replacement request corresponding to the third interface tag to the second terminal;

[0029] After receiving the skeleton code replacement confirmation information and the second skeleton replacement file returned by the second terminal, the second skeleton replacement file is overwritten to the skeleton code part corresponding to the third interface mark.

[0030] In a second aspect, the present invention further provides an animation keel real-time debugging device, comprising:

[0031] A file acquisition module, used to acquire the animation keel sent by the first terminal and the first skeleton replacement file sent by the second terminal;

[0032] An interface acquisition module, used for extracting a first interface mark from the first bone replacement file;

[0033] An interface traversal module, used for traversing all interface marks included in the animation keel, and determining a second interface mark that matches the first interface mark;

[0034] A code replacement module, used for overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain a debugged animation keel;

[0035] A debugging confirmation module, used for sending the debugged animation keel to the first terminal;

[0036] The debugging and publishing module is used to publish the debugged animation keel after receiving the debugging confirmation information fed back by the first terminal.

[0037] In a third aspect, the present invention further provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of any one of the animation keel real-time debugging methods in the first aspect.

[0038] In a fourth aspect, the present invention further provides a computer device, comprising a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, it executes any one of the animation keel real-time debugging methods in the first aspect.

[0039] The beneficial effects of adopting the above technical solution are as follows: the real-time debugging solution for animation keels provided in this embodiment utilizes some skeleton interfaces of the animation keel to partially replace the keel file, thereby breaking the problem in the prior art that all animation keels need to be loaded for each animation keel debugging, thereby shortening the file compilation and loading time during the animation keel debugging process; and, displaying animation keels in different formats according to the debugging modes of different functional ends, thereby reducing the communication costs caused by different animation keel display methods of different functional ends and improving the debugging efficiency of the animation keel. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art are briefly introduced below.

[0041] Figure 1 This is a schematic diagram of a real-time debugging method for an animation keel in one embodiment of the present application;

[0042] Figure 2 This is a schematic diagram of a real-time debugging device for an animated keel in one embodiment of the present application. DETAILED DESCRIPTION

[0043] The technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all of the embodiments. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention. In order to explain the present invention in more detail, the animation keel real-time debugging method, device, storage medium and equipment provided by the present invention are specifically described below in conjunction with the drawings.

[0044] Unless otherwise defined, the technical terms or scientific terms used in the disclosure of this application should be understood by people with ordinary skills in the field to which the present invention belongs. The "first", "second" and similar words used in the present invention do not indicate any order, quantity or importance, but are only used to distinguish different components. Similarly, similar words such as "one", "one" or "the" do not indicate a quantitative limit, but indicate that there is at least one. Similar words such as "include" or "include" mean that the elements or objects appearing in front of the word cover the elements or objects listed after the word and their equivalents, without excluding other elements or objects. Similar words such as "connect" or "connected" are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. "Up", "down", "left", "right" and the like are only used to indicate relative positional relationships. When the absolute position of the described object changes, the relative positional relationship can also change accordingly.

[0045] Animation skeleton refers to the internal structure used to define the movable parts of a character in an animation or game. It is the basic framework of an animation or game character. Designers or artists usually control the display effects or movements of the character by manipulating the animation skeleton.

[0046] The present invention provides a method for real-time debugging of animation keels. By receiving the debugging of local skeletons of animation keels by different functional terminals at the engine end, the situation that different functional terminals need to load all animation keels for each debugging is reduced, and the animation keels are debugged and read in real time, thereby improving the debugging and communication efficiency of the same animation keel by different functional terminals. This method is applied to a terminal device as an example for explanation. Figure 1 A schematic diagram of the animation keel real-time debugging method is shown.

[0047] The embodiment of the present application provides an application scenario of the animation keel real-time debugging method, and the application scenario includes the terminal device provided in the embodiment, and the terminal device includes but is not limited to a smart phone and a computer device, wherein the computer device can be at least one of a desktop computer, a portable computer, a laptop computer, a mainframe computer, a tablet computer, etc. The terminal device obtains the animation keel and the first skeleton replacement file sent by the user end, generates the debugged animation keel and sends it to the designer or artist for confirmation and release. For the specific process, please refer to the embodiment of the animation keel real-time debugging method.

[0048] It should be noted that in the embodiment of the present application, the terminal device is equipped with an animation keel engine - CocosCreator engine, which can import animation keels (including texture sets and JSON files) and can view and set basic parameters in the engine. The above animation keel engine provides a first workflow for designers or artists and a second workflow for program developers, so that people at different functional ends can edit the animation keel at the same time.

[0049] The following is an explanation of the steps for configuring the animation keel real-time debugging method to be executed by the terminal device of the Cocos Creator engine:

[0050] Step S101, obtaining an animation keel sent by a first terminal and a first skeleton replacement file sent by a second terminal.

[0051] Taking into account the editing characteristics of the animation keel, in this embodiment, the first terminal is a terminal edited by a designer or artist, and the animation keel is displayed in the first terminal in the form of a picture (including a collection of JSON files and texture sets); the second terminal is a terminal edited by a program developer, and the second terminal debugs the animation keel through code.

[0052] It should be noted that the animation keel sent by the first terminal in step S101 is a complete keel file, which contains at least one bone, and each bone is a part of the animation keel; the first bone replacement file contains the bone part code that needs to be debugged. Taking the animation keel to display the character of the animation or game as an example, the animation keel sent by the first terminal is the whole character, and the first bone replacement file sent by the second terminal needs to adjust the local parts of the character, such as the head, hands, body, legs, etc. of the character, and each adjustable local part of the character is provided with a corresponding bone slot.

[0053] Furthermore, in this embodiment, in order to reduce the loading of unnecessary data, the animation keel sent by the first terminal is a JSON file; after receiving the first skeleton replacement file sent by the second terminal, the format of the first skeleton replacement file is obtained, and after receiving the animation keel, the animation keel file needs to be converted into a compiled file with the same format as the first skeleton replacement file, and the compilation format of the animation keel is unified at the engine, thereby facilitating subsequent animation keel debugging.

[0054] Step S102: extracting a first interface marker from the first skeleton replacement file.

[0055] Specifically, the first interface mark is used to indicate the slot corresponding to the skeletal part that needs to be debugged, and the slot corresponding to the skeletal part that needs to be debugged is found through the first interface mark.

[0056] Step S103, traverse all interface marks included in the animation keel, and determine a second interface mark that matches the first interface mark.

[0057] It should be noted that there are multiple bones in the animation keel, each adjustable bone is provided with a specific slot, each slot corresponds to an interface tag, and the bone part to be debugged by the second terminal can be determined by traversing the interface tags. The first interface tag and the second interface tag are the only matching mapping relationships, which can be displayed in the same code, in plain text and cipher text, or in the form of public key and private key.

[0058] Step S104, overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain the debugged animation skeleton.

[0059] Specifically, after determining the slot corresponding to the skeleton part to be debugged, the first skeleton replacement file of the second terminal is overwritten to the skeleton code part of the original animation keel, and a new animation keel can be obtained after the overwriting is completed.

[0060] Step S105, sending the debugged animation keel to the first terminal.

[0061] Specifically, when step S105 feeds back the debugged animation skeleton to the first terminal, the animation skeleton needs to be adjusted to a format readable by designers or artists, including: converting the debugged animation skeleton into a set of JSON files and texture sets; sending the set of JSON files and texture sets, and a post-debugging confirmation request to the first terminal.

[0062] Step S106: after receiving the debugging confirmation information fed back by the first terminal, the debugged animation keel is released.

[0063] Specifically, the debugged animation keel needs to be sent to the first terminal for review to see if it meets the expected debugging effect. If it meets the expected debugging effect, the first terminal will feedback the debugging confirmation information and then release the debugged animation keel. If it does not meet the expected debugging effect, the first terminal will feedback the re-debugging requirements and the skeleton parts that need to be debugged, and forward it to the second terminal to achieve efficient communication of animation keel debugging.

[0064] This embodiment uses part of the skeleton interface of the animation keel to partially replace the keel file, breaking the problem in the prior art that each animation keel debugging requires loading all the animation keels, and shortening the file compilation and loading time during the animation keel debugging process. Furthermore, this embodiment displays animation keels in different formats for debugging modes of different functional terminals (for example, the first terminal for designers or artists displays the animation keel in the form of pictures, and the second terminal for program developers displays the animation keel in the form of codes), reducing the communication costs caused by different display methods of animation keels at different functional terminals, and improving the debugging efficiency of animation keels.

[0065] Furthermore, before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark in step S104, the following steps are also included:

[0066] Step S201, if the second interface mark includes a file non-debuggable tag, send skeleton code non-debuggable information and the skeleton part corresponding to the second interface mark to the first terminal and / or the second terminal.

[0067] Step S202: If the second interface mark includes a file debuggable tag, a bone replacement request is sent to the second terminal. After receiving the bone replacement confirmation information sent by the second terminal, the first bone replacement file is overwritten to the bone code part corresponding to the second interface mark.

[0068] Specifically, considering that not all skeletal parts in the animation skeleton can be debugged by the program developer, an adjustable label and a non-debuggable label can be set on the interface mark of the skeletal part. If the second interface mark found by the first skeletal replacement file sent by the second terminal representing the program developer contains a non-debuggable label, it is necessary to send instructions to the second terminal of the program developer and / or the first terminal of the artist to confirm whether the skeletal part needs to be debugged. If an indication is given to debug, a request for changing the debugging authority can be sent to the first terminal to change whether the skeletal part is debuggable, that is, to change the original non-debuggable label to an adjustable label.

[0069] Furthermore, before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark in step S104, the following steps are also included:

[0070] Step S301, comparing the skeleton code corresponding to the second interface mark with the first skeleton replacement file.

[0071] Step S302: If the skeleton code is the same as the first skeleton replacement file, a skeleton replacement code verification message is sent to the second terminal.

[0072] Step S303: If the similarity between the skeleton code and the first skeleton replacement file is lower than a first threshold, a skeleton replacement code verification message is sent to the second terminal.

[0073] Before overwriting the code of the skeleton part that needs to be debugged, compare the code before overwriting and the replacement code. If it is found that the code before overwriting is the same as the replacement code, confirm with the second terminal that sends the replacement code whether the uploaded first skeleton replacement file is correct; similarly, if the difference between the code before overwriting and the replacement code is too large (that is, the above similarity is lower than the first threshold), it is also necessary to confirm with the second terminal that sends the replacement code whether the uploaded first skeleton replacement file is correct; after receiving the confirmation replacement instruction from the second terminal, overwrite the code of the skeleton part that needs to be debugged. The setting of this step can reduce the situation where the second terminal mistakenly uploads old debugging code or irrelevant code, and improve the accuracy of animation keel debugging.

[0074] Furthermore, considering that the present embodiment is to adjust the animation skeleton of an animation or game character, the local skeleton part has symmetry, such as the eyes, hands, legs, etc. of the character. In order to improve the debugging efficiency and avoid inconsistent debugging of symmetrical skeleton parts, the following steps can also be set to debug the symmetrical partial skeleton:

[0075] Step S401: judging whether the animation keel also includes the same type of skeletal part information according to the skeletal part information marked by the second interface.

[0076] Step S402: If the animation keel also includes the same type of skeletal part information, obtain the third interface mark corresponding to the same type of skeletal part information.

[0077] The same type of skeletal part information may specifically be symmetrical skeletal part information in a character, such as ears, eyes, hands, fingers, legs, etc. of the character.

[0078] Step S403: Send a skeleton code replacement request corresponding to the third interface tag to the second terminal.

[0079] Step S404, after receiving the skeleton code replacement confirmation information and the second skeleton replacement file returned by the second terminal, overwrite the second skeleton replacement file to the skeleton code part corresponding to the third interface mark.

[0080] It should be noted that, although the above-mentioned same type of bone part information is symmetrical, the first bone replacement file and the second bone replacement file may contain the same bone code or different bone codes.

[0081] It should be understood that although the Figure 1 The steps in the flowchart are shown in sequence as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of these steps, and these steps can be executed in other orders. Figure 1 At least part of the steps may include multiple sub-steps or sub-stages. These sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least part of the sub-steps or stages of other steps.

[0082] The above embodiments of the present invention describe in detail the real-time debugging method of the animation keel. The above method disclosed by the present invention can be implemented by various devices. Therefore, the present invention also discloses a real-time debugging device for the animation keel. Figure 2 , specific embodiments are given below to explain in detail.

[0083] The file acquisition module 501 is used to acquire the animation keel sent by the first terminal and the first skeleton replacement file sent by the second terminal;

[0084] An interface acquisition module 502 is used to extract a first interface mark from the first bone replacement file;

[0085] An interface traversal module 503, used for traversing all interface marks included in the animation keel, and determining a second interface mark that matches the first interface mark;

[0086] A code replacement module 504 is used to overwrite the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain a debugged animation keel;

[0087] The debugging confirmation module 505 is used to send the debugged animation keel to the first terminal;

[0088] The debugging and publishing module 506 is used to publish the debugged animation keel after receiving the debugging confirmation information fed back by the first terminal.

[0089] Furthermore, the animation keel real-time debugging device also includes:

[0090] The skeleton non-debuggable module 601 is used to send skeleton code non-debuggable information and the skeleton part corresponding to the second interface mark to the first terminal and / or the second terminal if the second interface mark includes a file non-debuggable tag;

[0091] The skeleton adjustable module 602 is used to send a skeleton replacement request to the second terminal if the second interface mark includes a file debuggable tag, and after receiving the skeleton replacement confirmation information sent by the second terminal, overwrite the first skeleton replacement file to the skeleton code part corresponding to the second interface mark.

[0092] Furthermore, the animation keel real-time debugging device also includes:

[0093] A code comparison module 701 is used to compare the skeleton code corresponding to the second interface mark with the first skeleton replacement file;

[0094] The anti-duplicate debugging module 702 is used to send a skeleton replacement code verification message to the second terminal if the skeleton code is the same as the first skeleton replacement file;

[0095] The error-proof debugging module 703 is used to send a skeleton replacement code verification message to the second terminal if the similarity between the skeleton code and the first skeleton replacement file is lower than a first threshold.

[0096] Furthermore, the animation keel real-time debugging device also includes:

[0097] A similar bone search module 801 is used to determine whether the animation keel also includes the same type of bone part information according to the bone part information marked by the second interface;

[0098] The interface mark acquisition module 802 is used to acquire a third interface mark corresponding to the same type of skeletal part information if the animation keel also includes the same type of skeletal part information;

[0099] The same type skeleton debugging application module 803 is used to send a skeleton code replacement request corresponding to the third interface mark to the second terminal;

[0100] The same type skeleton debugging module 804 is used to overwrite the second skeleton replacement file to the skeleton code part corresponding to the third interface mark after receiving the skeleton code replacement confirmation information and the second skeleton replacement file returned by the second terminal.

[0101] For the animation keel real-time debugging device, all the above-mentioned methods can be referred to, and no further details will be given here. Each module in the above-mentioned device can be implemented in whole or in part by software, hardware and a combination thereof. Each of the above-mentioned modules can be embedded in or independent of the processor of the terminal device in the form of hardware, or can be stored in the memory of the terminal device in the form of software, so that the processor can call and execute the operations corresponding to each of the above modules.

[0102] In one embodiment, the present invention further provides a computer-readable storage medium having a computer program stored thereon, and when the computer program is executed by a processor, the steps of the above-mentioned animation keel real-time debugging method are implemented.

[0103] The computer-readable storage medium may be an electronic memory such as a flash memory, an EEPROM (electrically erasable programmable read-only memory), an EPROM (erasable programmable read-only memory), a hard disk or a ROM. Optionally, the computer-readable storage medium includes a non-transitory computer-readable storage medium. The computer-readable storage medium has a storage space for program codes for executing any method step of the above method. These program codes may be read from or written into one or more computer program products, and the program codes may be compressed in an appropriate form.

[0104] In one embodiment, the present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the above-mentioned animation keel real-time debugging method when executing the computer program.

[0105] The computer device includes a memory, a processor and one or more computer programs, wherein the one or more computer programs can be stored in the memory and configured to be executed by one or more processors, and the one or more application programs are configured to execute the above-mentioned animation keel real-time debugging method.

[0106] The processor may include one or more processing cores. The processor uses various interfaces and lines to connect the various parts of the entire computer device, and executes various functions of the computer device and processes data by running or executing instructions, programs, code sets or instruction sets stored in the memory, and calling data stored in the memory. Optionally, the processor can be implemented in at least one hardware form of digital signal processing (Digital Signal Processing, DSP), field programmable gate array (Field-Programmable Gate Array, FPGA), and programmable logic array (Programmable Logic Array, PLA). The processor can integrate one or more combinations of a central processing unit (Central Processing Unit, CPU), a reporting verifier (Graphics Processing Unit, GPU) for buried data, and a modem. Among them, the CPU mainly processes the operating system, user interface, and application programs; the GPU is responsible for rendering and drawing display content; and the modem is used to process wireless communications. It can be understood that the above-mentioned modem may not be integrated into the processor, but may be implemented separately through a communication chip.

[0107] The memory may include a random access memory (RAM) or a read-only memory (ROM). The memory may be used to store instructions, programs, codes, code sets or instruction sets. The memory may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as a touch function, a sound playback function, an image playback function, etc.), instructions for implementing the above-mentioned various method embodiments, etc. The data storage area may also store data created by the terminal device during use, etc.

[0108] The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features may be replaced by equivalents. However, 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 embodiments of the present invention.

Claims

1. A real-time debugging method for an animation keel, characterized in that: include: Obtain the animation keel sent by the first terminal and the first skeleton replacement file sent by the second terminal; extracting a first interface marker from the first bone replacement file; Traversing all interface marks included in the animation keel, and determining a second interface mark that matches the first interface mark; Overwrite the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain the debugged animation keel; Sending the debugged animation keel to the first terminal; After receiving the debugging confirmation information fed back by the first terminal, the debugged animation keel is released.

2. The animation keel real-time debugging method according to claim 1, characterized in that: The animation keel sent by the first terminal is a JSON file; The animation keel file is converted into a compiled file in the same format as the first skeleton replacement file.

3. The animation keel real-time debugging method as claimed in claim 2, characterized in that: Before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark, the following steps are also included: If the second interface mark includes a file non-debuggable tag, sending skeleton code non-debuggable information and the skeleton part corresponding to the second interface mark to the first terminal and / or the second terminal; If the second interface mark includes a file debuggable tag, a bone replacement request is sent to the second terminal. After receiving the bone replacement confirmation information sent by the second terminal, the first bone replacement file is overwritten to the bone code part corresponding to the second interface mark.

4. The real-time debugging method of the animation keel as claimed in claim 2, characterized in that: Before overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark, the following steps are also included: Compare the skeleton code corresponding to the second interface mark with the first skeleton replacement file; If the skeleton code is the same as the first skeleton replacement file, a skeleton replacement code verification message is sent to the second terminal.

5. The animation keel real-time debugging method as claimed in claim 4, characterized in that: Also includes: If the similarity between the skeleton code and the first skeleton replacement file is lower than a first threshold, a skeleton replacement code verification message is sent to the second terminal.

6. The animation keel real-time debugging method as claimed in claim 2, characterized in that: The sending of the debugged animation keel to the first terminal is specifically: Convert the debugged animation keel into a set of JSON files and texture sets; The set of the JSON file and the texture set, and a post-debugging confirmation request are sent to the first terminal.

7. The animation keel real-time debugging method as claimed in claim 2, characterized in that: Also includes: Determine whether the animation keel also includes the same type of bone part information according to the bone part information marked by the second interface; If the animation keel also includes the same type of bone part information, obtaining the third interface mark corresponding to the same type of bone part information; Sending a skeleton code replacement request corresponding to the third interface tag to the second terminal; After receiving the skeleton code replacement confirmation information and the second skeleton replacement file returned by the second terminal, the second skeleton replacement file is overwritten to the skeleton code part corresponding to the third interface mark.

8. A real-time debugging device for an animated keel, characterized in that: include: A file acquisition module, used to acquire the animation keel sent by the first terminal and the first skeleton replacement file sent by the second terminal; An interface acquisition module, used for extracting a first interface mark from the first bone replacement file; An interface traversal module, used for traversing all interface marks included in the animation keel, and determining a second interface mark that matches the first interface mark; A code replacement module, used for overwriting the first skeleton replacement file to the skeleton code portion corresponding to the second interface mark to obtain a debugged animation keel; A debugging confirmation module, used for sending the debugged animation keel to the first terminal; The debugging and publishing module is used to publish the debugged animation keel after receiving the debugging confirmation information fed back by the first terminal.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the animation keel real-time debugging method according to any one of claims 1 to 7 are implemented.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it executes the animation keel real-time debugging method according to any one of claims 1 to 7.

Images