Real-time debugging method, device, storage medium and equipment for animated keel

Abstract

This invention provides a method, apparatus, storage medium, and device for real-time debugging of animation skeletons, comprising: acquiring an animation skeleton sent by a first terminal and a first bone replacement file sent by a second terminal; extracting a first interface marker from the first bone replacement file; traversing all interface markers contained in the animation skeleton to determine a second interface marker that matches the first interface marker; overwriting the bone code portion corresponding to the second interface marker with the first bone replacement file to obtain a debugged animation skeleton; sending the debugged animation skeleton to the first terminal; and publishing the debugged animation skeleton after receiving debugging confirmation information from the first terminal. By receiving debugging of local bones of the animation skeleton from different functional terminals at the engine end, the debugging efficiency of different functional terminals for the same animation skeleton is improved.

Description

Technical Field

[0001] This invention relates to the field of animation, and more specifically to a method, apparatus, storage medium, and device for real-time debugging of animation keel. Background Technology

[0002] Dragonbone Animation is a 2D game animation platform for designers, providing solutions for 2D skeletal animation. Currently, Dragonbone Animation only allows viewing static animation models, not the animation effects, and modifying the data of a specific bone within the animation keel requires re-importing the keel file to view the changes.

[0003] In existing technologies, designers or artists typically generate keel files as images. 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. This results in the animation keel debugging process taking up a lot of time for both artists and programmers. Furthermore, due to the significant differences in their roles, the continuous loading of all the debugged keel files during the animation keel debugging process leads to time-consuming communication and low collaboration efficiency. Summary of the Invention

[0004] Based on this, the present invention provides a method, apparatus, storage medium and device for real-time debugging of animation keel. By receiving the debugging of local bones of animation keel from different functional terminals at the engine end, the situation where different functional terminals need to load the entire animation keel for each debugging is reduced, thereby realizing real-time debugging and reading of animation keel and improving the efficiency of debugging and communication between different functional terminals for the same animation keel.

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

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

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

[0008] Iterate through all the interface markers contained in the animation keel and determine the second interface marker that matches the first interface marker;

[0009] The first bone replacement file is overwritten with the bone code section corresponding to the second interface mark to obtain the debugged animated keel;

[0010] The debugged animated keel is sent to the first terminal;

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

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

[0013] Convert the animated keel file into a compiled file in the same format as the first bone replacement file.

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

[0015] If the second interface tag includes a file that cannot be debugged, send the skeleton code that cannot be debugged, as well as the skeleton part corresponding to the second interface tag, to the first terminal and / or the second terminal.

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

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

[0018] Compare the skeletal code corresponding to the second interface marker with the first skeletal replacement file;

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

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

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

[0022] Furthermore, sending the debugged animated keel to the first terminal specifically involves:

[0023] The debugged animated keel is converted into a collection of JSON files and texture sets;

[0024] The JSON file, the collection of texture sets, and the confirmation request after debugging are sent to the first terminal.

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

[0026] Based on the skeletal part information marked by the second interface, determine whether the animated keel also includes skeletal part information of the same type;

[0027] If the animated keel also includes bone part information of the same type, obtain the third interface tag corresponding to the bone part information of the same type;

[0028] Send a skeletal code replacement request corresponding to the third interface marker to the second terminal;

[0029] After receiving the skeletal code replacement confirmation information and the second skeletal replacement file returned by the second terminal, the second skeletal replacement file is overwritten onto the skeletal code portion corresponding to the third interface marker.

[0030] Secondly, the present invention also provides a real-time debugging device for an animated keel, comprising:

[0031] The file acquisition module is 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 is used to extract a first interface marker from the first skeleton replacement file;

[0033] The interface traversal module is used to traverse all interface markers contained in the animation keel and determine the second interface marker that matches the first interface marker.

[0034] The code replacement module is used to overwrite the bone code part corresponding to the second interface mark with the first bone replacement file to obtain the debugged animation keel;

[0035] The debugging confirmation module is used to send the debugged animated keel to the first terminal;

[0036] The debugging and publishing module is used to publish the debugged animated keel after receiving the debugging confirmation information from the first terminal.

[0037] Thirdly, the present invention also 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 of the animation keel real-time debugging methods in the first aspect.

[0038] Fourthly, the present invention also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to perform 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 keel provided in this embodiment uses part of the skeleton interface of the animation keel to partially replace the keel file, breaking the problem that the entire animation keel needs to be loaded every time the animation keel is debugged in the prior art, shortening the file compilation and loading time in the animation keel debugging process; in addition, it displays animation keels in different formats for debugging modes of different functional ends, reducing the communication costs caused by different display methods of animation keels by different functional ends, and improving the debugging efficiency of animation keels. Attached Figure Description

[0040] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below.

[0041] Figure 1 This is a schematic diagram of a real-time debugging method for animated keel in one embodiment of this application;

[0042] Figure 2 This is a schematic diagram of a real-time debugging device for the animation keel in one embodiment of this application. Detailed Implementation

[0043] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention. To describe the present invention in more detail, the animation keel real-time debugging method, apparatus, storage medium, and device provided by the present invention will be specifically described below with reference to the accompanying drawings.

[0044] Unless otherwise defined, the technical or scientific terms used in this application shall have the ordinary meaning understood by one of ordinary skill in the art to which this invention pertains. The terms "first," "second," and similar terms used in this invention do not indicate any order, quantity, or importance, but are merely used to distinguish different components. Similarly, the terms "an," "a," or "the" do not indicate a quantity limitation, but rather indicate the presence of at least one. The terms "comprising" or "including" mean that the preceding element or object encompasses the elements or objects listed after the word and their equivalents, without excluding other elements or objects. The terms "connected" or "linked" are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. "Up," "down," "left," "right," etc., are used only to indicate relative positional relationships; when the absolute position of the described object changes, the relative positional relationship may also change accordingly.

[0045] Animation keel refers to the internal structure used in animation or games to define the movable parts of a character. It is the basic framework of an animation or game character, and designers or artists usually manipulate the animation keel to control the character's display effects or movements.

[0046] This invention provides a real-time debugging method for animation keels. By receiving debugging requests for local skeletons of the animation keel from different functional units at the engine end, it reduces the need to load the entire animation keel for each debugging session, enabling real-time debugging and reading of the animation keel and improving the communication efficiency of debugging the same animation keel from different functional units. The method is illustrated using a terminal device as an example, in conjunction with the appendix. Figure 1 The diagram shows a real-time debugging method for the animated keel.

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

[0048] It should be noted that, in this embodiment, the terminal device is equipped with an animation keel engine—the CocosCreator engine—which can import animation keels (including texture sets and JSON files) and view and set basic parameters within the engine. The aforementioned animation keel engine provides a first workflow for designers or artists and a second workflow for programmers, enabling personnel from different roles to edit animation keels simultaneously.

[0049] The following describes the steps for applying the real-time debugging method for animated keels to configuring terminal devices running the Cocos Creator engine:

[0050] Step S101: Obtain the animated keel sent by the first terminal and the first bone replacement file sent by the second terminal.

[0051] Considering the editing characteristics of the animated keel, in this embodiment, the first terminal is a terminal edited by designers or artists, and the animated keel is displayed on the first terminal in the form of images (including JSON files and texture sets); the second terminal is a terminal edited by program developers, and the second terminal debugs the animated 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 code for the bone parts that need to be debugged. Taking the animation keel displaying an animated or game character as an example, the animation keel sent by the first terminal is the entire character, while the first bone replacement file sent by the second terminal needs to adjust the local parts of the character, such as the character's head, hands, body, legs, etc. Each adjustable local part of the character is provided with a corresponding bone slot.

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

[0054] Step S102: Extract the first interface marker from the first bone replacement file.

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

[0056] Step S103: Traverse all interface markers contained in the animation keel and determine the second interface marker that matches the first interface marker.

[0057] It should be noted that the animation keel contains multiple bones, each adjustable bone has a specific slot, and each slot corresponds to an interface marker. The bone portion that the second terminal needs to debug can be determined by traversing the interface markers. The first interface marker and the second interface marker have a unique matching mapping relationship, which can be displayed using the same code, plaintext and ciphertext, or public and private keys.

[0058] Step S104: Overwrite the first bone replacement file onto the bone code section corresponding to the second interface mark to obtain the debugged animation keel.

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

[0060] Step S105: Send the debugged animated keel to the first terminal.

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

[0062] Step S106: After receiving the debugging confirmation information from the first terminal, the debugged animation keel is published.

[0063] Specifically, the debugged animation skeleton 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 provide debugging confirmation information, and then the debugged animation skeleton can be released. If it does not meet the expected debugging effect, the first terminal will provide feedback on the need for further debugging and the skeleton parts that need to be debugged, and forward it to the second terminal to achieve efficient communication in the debugging of the animation skeleton.

[0064] This embodiment utilizes a portion of the animation keel's skeleton interface to partially replace the keel file, overcoming the problem in existing technologies where the entire animation keel needs to be loaded for each animation keel debugging session, thus shortening the file compilation and loading time during the animation keel debugging process. Furthermore, this embodiment displays different formats of animation keels for different functionalities during debugging (e.g., displaying the animation keel as an image for the first terminal of designers or artists, and displaying the animation keel as code for the second terminal of programmers), reducing communication costs caused by different display methods for animation keels across different functionalities and improving the debugging efficiency of animation keels.

[0065] Furthermore, before step S104 where the first bone replacement file is overwritten onto the bone code portion corresponding to the second interface marker, the following steps are also included:

[0066] Step S201: If the second interface tag includes a file that cannot be debugged, send the skeleton code that cannot be debugged and the skeleton part corresponding to the second interface tag to the first terminal and / or the second terminal.

[0067] Step S202: If the second interface tag includes a file debuggable tag, send a skeleton replacement request to the second terminal. After receiving the skeleton replacement confirmation information sent by the second terminal, overwrite the skeleton code part corresponding to the second interface tag with the first skeleton replacement file.

[0068] Specifically, considering that not all skeletal parts in the animation keel can be debugged by the programmers, the interface tags of the skeletal parts can be set with adjustable and non-adjustable tags. If the second interface tag found by the first skeletal replacement file sent by the second terminal representing the programmer contains a non-adjustable tag, then it is necessary to send instructions to the second terminal of the programmer and / or the first terminal of the artist to confirm whether the skeletal part needs to be debugged. If the instruction to debug is received, a request to change the debugging permission can be sent to the first terminal to change the nature of whether the skeletal part is debuggable, that is, to change the original non-adjustable tag to an adjustable tag.

[0069] Furthermore, before step S104 where the first bone replacement file is overwritten onto the bone code portion corresponding to the second interface marker, the following steps are also included:

[0070] Step S301: Compare the bone code corresponding to the second interface mark with the first bone replacement file.

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

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

[0073] Before overwriting the code for the skeletal portion requiring debugging, the code before overwriting and the replacement code are compared. If the code before overwriting and the replacement code are found to be identical, the second terminal that sent the replacement code is contacted to confirm whether the uploaded first skeletal replacement file is correct. Similarly, if the code before overwriting and the replacement code differ significantly (i.e., the similarity is below the first threshold mentioned above), the second terminal that sent the replacement code is contacted to confirm whether the uploaded first skeletal replacement file is correct. After receiving confirmation of the replacement from the second terminal, the code for the skeletal portion requiring debugging is then overwritten. This step reduces the possibility of the second terminal mistakenly uploading outdated or irrelevant debugging code, thus improving the accuracy of animation keel debugging.

[0074] Furthermore, considering that this embodiment adjusts the animation skeleton of an animated or game character, and that some skeletal parts are symmetrical, such as the character's eyes, hands, and legs, in order to improve debugging efficiency and avoid inconsistencies in the debugging of symmetrical skeletal parts, the following steps can be set to debug the symmetrical skeletal parts:

[0075] Step S401: Determine whether the animation keel also includes the same type of bone part information based on the bone part information marked by the second interface.

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

[0077] Among them, the information on the same type of skeletal parts can be specifically the information on symmetrical skeletal parts in a character, such as the ears, eyes, hands, fingers, and legs of a character.

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

[0079] Step S404: After receiving the bone code replacement confirmation information and the second bone replacement file returned by the second terminal, the second bone replacement file is overwritten onto the bone code part corresponding to the third interface mark.

[0080] It should be noted that although the above-mentioned bone location information of the same type 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 attached Figure 1 The steps in the flowchart are shown sequentially according to 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 requirement for the execution of these steps, and they can be executed in other orders. Furthermore, [the following is a list of steps]. Figure 1 At least some of the steps in the process may include multiple sub-steps or sub-stages. These sub-steps or stages are not necessarily completed 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 some of the sub-steps or stages of other steps.

[0082] The above-described embodiments of the present invention describe in detail a method for real-time debugging of an animation keel. Since this method can be implemented using various types of devices, the present invention also discloses a device for real-time debugging of an animation keel, in conjunction with the appendix. Figure 2 The following are specific embodiments for detailed explanation.

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

[0084] The interface acquisition module 502 is used to extract the first interface marker from the first skeleton replacement file;

[0085] The interface traversal module 503 is used to traverse all interface markers contained in the animation keel and determine the second interface marker that matches the first interface marker.

[0086] The code replacement module 504 is used to overwrite the first bone replacement file onto the bone code part corresponding to the second interface mark to obtain the debugged animation keel;

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

[0088] The debugging and publishing module 506 is used to publish the debugged animated keel after receiving the debugging confirmation information from the first terminal.

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

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

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

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

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

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

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

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

[0097] The similar skeleton search module 801 is used to determine whether the animation keel also includes the same type of skeleton information based on the skeleton part information marked by the second interface;

[0098] The interface tag acquisition module 802 is used to acquire the third interface tag corresponding to the same type of bone part information if the animation keel also includes bone part information of the same type.

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

[0100] The similar skeleton debugging module 804 is used to overwrite 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 details regarding the real-time debugging device for the animation keel, please refer to the above description of the method's limitations; they will not be repeated here. Each module in the aforementioned device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of the terminal device in hardware form or independent of it, or stored in the memory of the terminal device in software form, so that the processor can call and execute the corresponding operations of each module.

[0102] In one embodiment, the present invention also 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 the above-described real-time debugging method for the animated keel.

[0103] The computer-readable storage medium may be an electronic storage device such as flash memory, EEPROM (Electrically Erasable Programmable Read-Only Memory), EPROM (Erasable Programmable Read-Only Memory), hard disk, or ROM. Optionally, the computer-readable storage medium includes a non-transitory computer-readable storage medium. The computer-readable storage medium has storage space for program code that performs any of the method steps described above. This program code can be read from or written to one or more computer program products, and the program code 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 computer program to perform the above-described real-time debugging method for animated keel.

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

[0106] A processor may include one or more processing cores. The processor connects to various parts of the computer device using various interfaces and lines, and performs various functions and processes data by running or executing instructions, programs, code sets, or instruction sets stored in memory, and by calling data stored in memory. Optionally, the processor may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). The processor may integrate one or a combination of several of the following: Central Processing Unit (CPU), Graphics Processing Unit (GPU), and modem. The CPU primarily handles the operating system, user interface, and applications; the GPU is responsible for rendering and drawing the displayed content; and the modem handles wireless communication. It is understood that the modem may also be implemented separately as a communication chip, without being integrated into the processor.

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

[0108] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. An animation skeleton real-time debugging method, characterized in that, The method comprises the following steps: obtaining an animation skeleton sent by a first terminal and a first bone replacement file sent by a second terminal; the animation skeleton sent by the first terminal is a JSON file; converting the animation skeleton file into a compiled file in the same format as the first bone replacement file; extracting a first interface mark from the first bone replacement file; traversing all interface marks contained in the animation skeleton to determine a second interface mark matching the first interface mark; covering the first bone replacement file to a bone code part corresponding to the second interface mark to obtain a debugged animation skeleton; sending the debugged animation skeleton to the first terminal; after receiving debug confirmation information fed back by the first terminal, publishing the debugged animation skeleton; the step of sending the debugged animation skeleton to the first terminal specifically comprises the following steps: converting the debugged animation skeleton into a JSON file and a set of texture sets; sending the JSON file and the set of texture sets, and a debug confirmation request to the first terminal.

2. The animated-sprite real-time debugging method of claim 1, wherein, Before covering the first bone replacement file to the bone code part corresponding to the second interface mark, the method further comprises the following steps: if the second interface mark comprises a file non-debug label, sending bone code non-debug information and a bone part corresponding to the second interface mark to the first terminal and / or the second terminal; if the second interface mark comprises a file debug label, sending a bone replacement request to the second terminal, and after receiving bone replacement confirmation information sent by the second terminal, covering the first bone replacement file to the bone code part corresponding to the second interface mark.

3. The animated-sprite real-time debugging method of claim 1, wherein, Before covering the first bone replacement file to the bone code part corresponding to the second interface mark, the method further comprises the following steps: comparing a bone code corresponding to the second interface mark with the first bone replacement file; if the bone code is the same as the first bone replacement file, sending a bone replacement code check message to the second terminal.

4. The animated-sprite real-time debugging method of claim 3, wherein, The method further comprises the following steps: if the similarity of the bone code and the first bone replacement file is lower than a first threshold value, sending a bone replacement code check message to the second terminal.

5. The animated-sprite real-time debugging method of claim 1, wherein, The method further comprises the following steps: determining whether the animation skeleton still comprises bone part information of the same type according to the bone part information of the second interface mark; if the animation skeleton still comprises bone part information of the same type, obtaining a third interface mark corresponding to the bone part information of the same type; sending a bone code replacement request corresponding to the third interface mark to the second terminal; after receiving bone code replacement confirmation information returned by the second terminal and a second bone replacement file, covering the second bone replacement file to a bone code part corresponding to the third interface mark.

6. A real-time debugging device for an animated keel, characterized in that, The method comprises the following steps: a file obtaining module is configured to obtain an animation skeleton sent by a first terminal and a first bone replacement file sent by a second terminal; the animation skeleton sent by the first terminal is a JSON file; the file obtaining module is further configured to convert the animation skeleton file into a compiled file in the same format as the first bone replacement file; an interface obtaining module is configured to extract a first interface mark from the first bone replacement file; An interface traversal module is configured to traverse all interface tags contained in the animation skeleton and determine a second interface tag matched with the first interface tag; A code replacement module is configured to replace the first bone replacement file to a bone code part corresponding to the second interface tag to obtain a debugged animation skeleton; A debug confirmation module is configured to send the debugged animation skeleton to the first terminal; A debug publishing module is configured to publish the debugged animation skeleton after receiving debug confirmation information fed back by the first terminal; The sending of the debugged animation skeleton to the first terminal specifically includes: Converting the debugged animation skeleton into a JSON file and a set of texture sets; Sending the JSON file and the set of texture sets, as well as a debug confirmation request, to the first terminal.

7. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the steps of the animation skeleton real-time debugging method in any one of claims 1-5.

8. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that, The processor executes the computer program to implement the animation skeleton real-time debugging method in any one of claims 1-5.

Images