Game testing method and device, electronic equipment and storage medium

Abstract

The application provides a game testing method and device, electronic equipment and a storage medium; the method comprises the following steps: in response to a test instruction of a game client for a target game, at least one subordinate robot object corresponding to a target main character object is logged in the target game, the target main character object being a player role object logged in the game client; in response to a player behavior operation of the game client for the target main character object, it is judged whether the player behavior operation hits any preset non-complete following operation; if the player behavior operation hits any preset non-complete following operation, the game logic corresponding to the hit non-complete following operation is executed on each subordinate robot object to obtain a first execution result; if the player behavior operation does not hit the preset non-complete following operation, the game logic corresponding to the player behavior operation is executed on each subordinate robot object to obtain a second execution result. The application can reduce the complexity of game logic testing.

Description

Technical Field

[0001] This invention relates to the field of testing technology, and in particular to a game testing method, apparatus, electronic device, and storage medium. Background Technology

[0002] Testing virtual games is a crucial process for verifying whether a virtual game can be released. In addition to stress and performance testing, game logic testing is also an important part of the testing process.

[0003] Existing game logic testing techniques generally involve writing customized scripts to make test bots simulate predetermined behaviors. This method requires writing a large number of scripts, requires professionals to implement, and has overly complex technical issues. Summary of the Invention

[0004] In view of this, the purpose of the present invention is to provide a game testing method, apparatus, electronic device and storage medium to reduce the complexity of game logic testing.

[0005] In a first aspect, embodiments of the present invention provide a game testing method applied to a game server. The method includes: responding to a test instruction from a game client for a target game, logging at least one subordinate robot object corresponding to a target protagonist object in the target game, wherein the target protagonist object is a player character object logged in the game client; responding to a player behavior operation from the game client for the target protagonist object, determining whether the player behavior operation hits any preset incomplete follow operation; if the player behavior operation hits any preset incomplete follow operation, then executing the game logic corresponding to the hit incomplete follow operation for each subordinate robot object to obtain a first execution result, wherein the first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal; if the player behavior operation does not hit any preset incomplete follow operation, then executing the game logic corresponding to the player behavior operation for each subordinate robot object to obtain a second execution result, wherein the second execution result is used to indicate whether the game logic corresponding to the player behavior operation is normal.

[0006] Secondly, embodiments of the present invention provide a game testing device applied to a game server. The device includes: a robot login module, configured to log at least one subordinate robot object corresponding to a target protagonist object in the target game in response to a test command from a game client for a target game, wherein the target protagonist object is a player character object logged in the game client; a first judgment module, configured to determine whether the player behavior operation hits any preset non-complete follow operation in response to a player behavior operation of the target protagonist object from the game client; a first execution module, configured to execute the game logic corresponding to the hit non-complete follow operation for each subordinate robot object if the player behavior operation hits any preset non-complete follow operation, and obtain a first execution result, wherein the first execution result is used to indicate whether the game logic corresponding to the hit non-complete follow operation is normal; and a second execution module, configured to execute the game logic corresponding to the player behavior operation for each subordinate robot object if the player behavior operation does not hit a preset non-complete follow operation, and obtain a second execution result, wherein the second execution result is used to indicate whether the game logic corresponding to the player behavior operation is normal.

[0007] Thirdly, embodiments of the present invention provide an electronic device, including a processor and a memory, wherein the memory stores machine-executable instructions that can be executed by the processor, and the processor executes the machine-executable instructions to implement the above-described game testing method.

[0008] Fourthly, embodiments of the present invention provide a computer-readable storage medium storing computer-executable instructions. When the computer-executable instructions are invoked and executed by a processor, the computer-executable instructions cause the processor to implement the above-described game testing method.

[0009] The embodiments of the present invention bring the following beneficial effects:

[0010] The aforementioned game testing method, apparatus, electronic device, and storage medium are applied to a game server. The method includes: responding to a test instruction from a game client for a target game, logging at least one subordinate robot object corresponding to a target protagonist object in the target game, wherein the target protagonist object is a player character object logged in the game client; responding to a player behavior operation from the game client for the target protagonist object, determining whether the player behavior operation hits any preset incomplete follow operation; if the player behavior operation hits any preset incomplete follow operation, then executing the game logic corresponding to the hit incomplete follow operation for each subordinate robot object to obtain a first execution result, wherein the first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal; if the player behavior operation does not hit any preset incomplete follow operation, then executing the game logic corresponding to the player behavior operation for each subordinate robot object to obtain a second execution result, wherein the second execution result is used to indicate whether the game logic corresponding to the player behavior operation is normal. In this method, the player's actions of the main character object drive at least one subordinate robot object to fully or partially follow the main character object's actions. By presetting different partial follow operations, the subordinate robot object can execute game logic different from the main character object's actions. It can also execute the same game logic as the main character object's actions according to the test requirements. Thus, game logic testing can be completed efficiently without writing test scripts / programs, reducing the complexity of game logic testing.

[0011] Other features and advantages of the invention will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention are realized and obtained in accordance with the structures particularly pointed out in the description, claims and drawings.

[0012] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0013] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0014] Figure 1 This is a flowchart of one embodiment of the game testing method in this invention;

[0015] Figure 2 This is a flowchart of another embodiment of the game testing method in this invention;

[0016] Figure 3 This is a flowchart of another embodiment of the game testing method in this invention;

[0017] Figure 4 A schematic diagram of a game testing device provided in an embodiment of the present invention;

[0018] Figure 5 A schematic diagram of another game testing device provided in an embodiment of the present invention;

[0019] Figure 6 A schematic diagram of another game testing device provided in an embodiment of the present invention;

[0020] Figure 7 This is a schematic diagram of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions 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, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms “comprising” or “having,” and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0023] For ease of understanding, the specific process of the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 1 One embodiment of the game testing method in this invention includes:

[0024] Step S10: The game server responds to the test command for the target game from the game client and logs in at least one subordinate robot object corresponding to the target protagonist object in the target game. The target protagonist object is the player character object logged in in the game client.

[0025] It is understood that the game server deploys all the game logic of the target game, which refers to the virtual game to be tested. In one implementation, this embodiment of the invention is executed in the test environment of the game server, where only players with developer privileges can log in. When the target game passes the test, it is then released to the production environment, resulting in a version that all players can log in to. Passing the test means that all the game logic of the target game is functioning correctly. It should be noted that in the test environment, the game client has a test interface displaying test controls. Players can input the bot information for testing through these controls and submit test commands to the game server. The game server responds to the test commands from the game client by logging in at least one subordinate bot object corresponding to the target protagonist object in the target game. The target protagonist object refers to the player character object logged in by a real player in the game client.

[0026] It should be noted that the target protagonist object has a bound subordinate relationship with at least one corresponding subordinate robot object. Each player character object logged into the target game can be bound to at least one subordinate robot object with a subordinate relationship for game logic testing. For example, when player character object A logs into game client 1, player character object A is bound to 5 corresponding subordinate robot objects A1-A5. When player character object B logs into game client 2, player character object B is bound to 4 corresponding subordinate robot objects B1-B4. Player character objects A and B can operate normally according to the game logic. For example, player character objects A and B can be teammates or opponents, and can participate in the same game / match, or engage in non-interactive behaviors. The subordinate robot objects bound to each other will perform corresponding fully follow or partially follow operations based on the player behavior of their respective target protagonist object, thereby achieving the testing of the corresponding game logic. Each subordinate robot object corresponds to a target protagonist object. For example, the target protagonist object corresponding to subordinate robot objects A1-A5 is player character object A, and the target protagonist object corresponding to subordinate robot objects B1-B4 is player character object B. The specific target protagonist object depends on the bound subordinate relationship and is not limited here.

[0027] In one implementation, to reduce the coupling between the game testing logic and the game logic, and to lower the load on the game server, the simulated connection / login between the subordinate robot object and the target game can be separated from the game server and executed on another server, referred to as the test server. Specifically, after responding to a test command from the game client for the target game, the game server forwards the robot information from the test command and relevant game server information to the test server, and sends a robot login command to the test server. Upon receiving the robot login command, the test server establishes a connection between at least one subordinate robot object corresponding to the target protagonist object and the target game, thus logging at least one subordinate robot object corresponding to the target protagonist object into the target game. It is understood that the behavior of each subordinate robot object is still executed on the game server through game logic. The test server is only used to simulate the game client logging into each subordinate robot object. This eliminates the need for additional scripts / programs to simulate the behavior of each subordinate robot object; it is driven solely by the target game's own game logic. This allows for accurate testing of the game logic while reducing the complexity of game testing.

[0028] It should be noted that each subordinate robot object holds a player role in the target game. Besides its behavior being driven by the behavior of the corresponding target protagonist object, it has the same game execution mechanism as the target protagonist object and is also a player role object in the target game. In one implementation, the player role attributes of each subordinate robot object can be the same as or different from the corresponding target protagonist object. For example, assuming that the player role attributes of a target protagonist object in the target game may include: Role 1, Class A, then the player role attributes of all subordinate robot objects corresponding to that target protagonist object may include: Role 1, Class A, Role 2, Class B, or other roles and classes; the specifics are not limited here. In one implementation, the player role attributes of subordinate robot objects can be set through the game client from the test interface. The robot information carried by the test command is submitted to the game server. The game server logs in at least one subordinate robot object corresponding to the target protagonist object in the target game according to the player role attributes in the robot information of each subordinate robot object, allowing different test robots to hold different role attributes, making the game test more comprehensive.

[0029] Step S20: The game server responds to the player's action on the target character object by determining whether the player's action hits any preset non-complete follow operation.

[0030] It should be noted that after logging into the target game, the behavior of the subordinate robot objects is entirely driven by the game logic in the game server, without the need for additional robot control scripts / programs. Specifically, in this embodiment, the subordinate robot objects of the target protagonist object can either completely follow the behavior of the target protagonist object or not completely follow it. When the game client performs any player action operation on the target protagonist object, the game server responds to the arbitrary player action operation by determining whether the player action operation is any preset non-completely followed operation, thereby determining whether the behavior of each subordinate robot object completely follows the behavior of the target protagonist object, that is, whether each subordinate robot object performs the same player action operation as the target protagonist object. Understandably, the game server has at least one pre-defined non-complete follow operation, called the pre-defined non-complete follow operation list. When the game server responds to a player's action on the target character object from the game client, it checks whether the player's action is included in the pre-defined non-complete follow operation list. If it is, the player's action is determined to have matched any of the pre-defined non-complete follow operations; otherwise, it is determined that the player's action has not matched any of the pre-defined non-complete follow operations. This determines the game logic to be executed by each subsequent subordinate robot object, so that the testing of game logic does not need to rely on a large number of terminal devices logging into real player accounts, reducing the dependence of game testing on terminal devices.

[0031] In one implementation, each player action corresponds to a unique action identifier, and each preset incomplete follow action also corresponds to a unique action identifier. When determining whether a player action matches any preset incomplete follow action, the action identifier corresponding to the player action is compared with the action identifiers corresponding to all preset incomplete follow actions to determine whether the player action matches any preset incomplete follow action. Specifically, determining whether a player action matches any preset incomplete follow action includes: determining whether the action identifier corresponding to the player action is the same as the action identifier corresponding to any preset incomplete follow action. If they are the same, the player action is determined to have matched any preset incomplete follow action; otherwise, if they are different, the player action has not matched any preset incomplete follow action. For example, suppose the target protagonist's movement operation requires each subordinate robot object to completely follow, that is, each subordinate robot object needs to perform the same movement operation. Then, the movement operation is a complete follow operation. None of the preset non-complete follow operations contain the behavior identifier A corresponding to the movement operation. When the target protagonist performs the player behavior operation of the movement operation, since the behavior identifier A is not included in the behavior identifiers corresponding to the preset non-complete follow operations, it is determined that the player behavior operation has not hit any preset non-complete follow operation. According to the result of the non-hit, each subordinate robot object is instructed to execute the game logic corresponding to the player behavior operation, that is, to instruct each subordinate robot object to also move with the target protagonist object, thereby realizing the complete follow operation of the test robot.

[0032] Next, let's illustrate the case where any preset incomplete follow operation is hit. For example, suppose the player action of the target protagonist object creating a team does not require each subordinate robot object to completely follow, but rather requires each subordinate robot object to perform an incomplete follow operation of joining the team created by the target protagonist object. In this case, the preset incomplete follow operation contains the behavior identifier B corresponding to the player action of joining the team. Since the behavior identifier corresponding to the preset incomplete follow operation contains behavior identifier B, when the target protagonist object performs the player action of creating a team, because the behavior identifier corresponding to the preset incomplete follow operation contains behavior identifier B, it is determined that the player action hits any preset incomplete follow operation. According to the hit result, each subordinate robot object is instructed to execute the game logic corresponding to the hit incomplete follow operation, that is, to instruct each subordinate robot object to perform the incomplete follow operation of joining the team created by the target protagonist object, thereby realizing the incomplete follow operation of the test robot. Understandably, in this example, since joining the team created by the target protagonist object is an interactive player action and part of the game logic, by executing the game logic corresponding to the incomplete follow operation by the subordinate robot object, it is possible to test whether the game logic corresponding to the incomplete follow operation is normal. Moreover, without writing scripts / programs to drive the robot's interactive behavior, the game logic can be tested in depth, greatly improving testing efficiency.

[0033] Step S30: If the player's action hits any preset incomplete follow operation, the game server executes the game logic corresponding to the hit incomplete follow operation on each subordinate robot object to obtain the first execution result. The first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal.

[0034] It should be noted that incomplete follow operations are also a type of player action, and therefore their execution logic is included in the game logic. When presetting incomplete follow operations, the association between player actions and the corresponding game logic can be pre-bound. When the target protagonist's player action hits any pre-set incomplete follow operation, the game server executes the corresponding game logic for each subordinate robot object based on the association between the player action and the incomplete follow operation, obtaining the first execution result. For example, player action B for creating a team is a pre-set incomplete follow operation. This player action B is pre-bound with player action C for joining a team or the game logic corresponding to player action C. When the target protagonist performs player action B for creating a team, the game logic for joining a team is executed based on this association, thereby testing the game logic for joining a team and determining whether the game logic for joining a team is normal.

[0035] In one implementation, in a test environment, the execution results of different game logics can be obtained through debugging tools. If an exception occurs during the execution of the game logic, the debugging tools can capture the exception information and output it to the developer through the execution results. Therefore, this implementation can determine whether the game logic corresponding to the non-complete follow operation has an exception during the execution process through the first execution result, thereby completing the test of the corresponding game logic.

[0036] Step S40: If the player's action does not hit the preset non-complete follow operation, the game server executes the game logic corresponding to the player's action on each subordinate robot object to obtain a second execution result. The second execution result is used to indicate whether the game logic corresponding to the player's action is normal.

[0037] Understandably, if the player's actions do not match the preset incomplete actions, each subordinate robot object can be driven to execute the same game logic as the player's actions. This allows the test robot to completely follow the player's actions, enabling the execution of game logic by robot objects with equal player status in the game without the need for a terminal device, thus completing the relevant game logic test. It should be noted that since the subordinate robot objects execute the same game logic as the player objects logged in via a terminal device in the target game and have equal player status, the second execution result obtained after driving all subordinate robot objects to execute the same game logic as the player's actions can also be used to indicate whether the game logic is normal when the player's actions are executed simultaneously by at least one player object. For example, assuming the target protagonist's attack on a monster is a complete follow-up action, and all subordinate robot objects and the target protagonist simultaneously attack the same monster, then the second execution result after the attack can determine whether the changes in the object's attributes / state are normal when the monster is attacked by multiple player objects simultaneously. For example, whether the monster's health decreases exponentially, whether the attack animation effects are stacked, etc., the specifics are not limited here.

[0038] In one implementation, since the number of subordinate robot objects can be set to any number, the first execution result and the second execution result can also be used to indicate the stress test results / game performance test results of the game server. This can be used for stress and performance testing of massively multiplayer online role-playing games (MMORPGs), and is not specifically limited here.

[0039] The game testing method provided by the above embodiments drives at least one subordinate robot object to fully or partially follow the behavior of the protagonist object through the player's operation behavior. By preset different partial follow operations, the subordinate robot object can be made to execute game logic different from the protagonist object's behavior. It can also be made to execute the same game logic as the protagonist object's behavior according to the test requirements. Thus, the game logic test can be completed efficiently without writing test scripts / programs, reducing the complexity of game logic testing.

[0040] Please see Figure 2 Another embodiment of the game testing method in this invention is applied to a game client and a game server. The game client provides a graphical user interface (GUI) displaying test controls. The method includes:

[0041] Step S201: In response to the submission operation of the robot information entered through the test control, the game client sends a test instruction to the target game. The test instruction includes the entered robot information, which is used to indicate the parameters of at least one subordinate robot object corresponding to the target protagonist object logged in the target game.

[0042] In this embodiment, testers can input the required robot information for the test robot through test controls in the graphical user interface provided by the game client. The test controls then trigger a submission operation, sending the input robot information to the target game's game server / test server via test commands to initiate the game testing process on both the game server and the test server. It is understood that test commands can be sent to either the game server or the test server. In one embodiment, the test command is sent to the game server, which then directly generates the subordinate robot object; alternatively, the game server may trigger the test server to generate the subordinate robot object. The specific implementation is not limited here.

[0043] Understandably, when the game client sends a test command to the game server, it also sends the input bot information. This bot information indicates parameters for at least one subordinate bot object corresponding to the target character in the target game; in other words, it indicates the parameters for the required test bot. In one implementation, the bot information includes at least one of the following: the number of target bots, the target login duration for each bot object, the name prefix / suffix for each bot object, and the player character attributes for each bot object. The bot information may also contain other data required for the test, which is not limited here.

[0044] Step S202: In response to the successful execution of the robot login command corresponding to the test command, the game client performs a hot update on the game communication protocol function in the game client to obtain the target game communication protocol function in the game client. The target game communication protocol function is used to indicate the communication protocol parameters of the player behavior operation of the target protagonist object and the communication protocol parameters of the follow operation of the subordinate robot object. The follow operation includes a preset non-complete follow operation and a preset complete follow operation. The target game communication protocol function is used to communicate with the target game.

[0045] It is understandable that communication between the game client and the game server is implemented through a unified game communication protocol function. As an example rather than a limitation, the protocol format of the game communication protocol function is usually: protocol number + protocol parameters, which is sent to the game server through the send(protocol number, protocol parameters) command. The game server can execute the corresponding game logic by parsing the command.

[0046] It should be noted that the protocol number in the game communication protocol function can be used to indicate the player action operation of the target protagonist object, and the protocol parameter can be used to indicate the communication protocol parameters of the player action operation of the target protagonist object. For example, in the send(BUY_GOODS, [DOODS_ID]) instruction, the protocol number "BUY_GOODS" refers to the player action operation of "buying goods", and the protocol parameter "DOODS_ID" refers to the ID of the goods to be purchased. After the game server receives this instruction, it executes the game logic of purchasing the goods of DOODS_ID, thereby completing the purchase behavior of the target protagonist object. In this step, after the game client responds to the game server's successful execution of the robot login command corresponding to the test command, that is, after the game server successfully logs in all subordinate robot objects according to the test command, the game client modifies the game communication protocol function in the game client through hot update. A communication protocol for subordinate robot objects is added to the game communication protocol function to obtain the target game communication protocol function. Therefore, in addition to the communication protocol parameters used to indicate the player's behavior operation of the target protagonist object, the target game communication protocol function can also be used to indicate the communication protocol parameters for the follow-up operation of subordinate robot objects, so that the behavior of subordinate robot objects can be driven at the same time as the behavior of player objects. As an example, and not a limitation, in this example, the target game communication protocol function obtained after hot update, when sending the communication protocol for purchasing goods, sends both the `send(BUY_GOODS, [DOODS_ID])` instruction and the `send(COPY_ACTION, [BUY_GOODS, [DOODS_ID]])` instruction. Here, `COPY_ACTION` is used to drive all subordinate robot objects to perform either a full follow operation or a partial follow operation. `BUY_GOODS` can be used to determine whether the player's action of "purchasing goods" matches any preset partial follow operation. If it matches, the game logic corresponding to the partial follow operation of "purchasing goods" is executed for each subordinate robot object, such as creating the goods before purchasing them. If it does not match, the game logic corresponding to the player's action of "purchasing goods" is executed, i.e., purchasing the same item. Specific details are not limited here. It is understood that the communication protocol parameters in the game communication protocol function can be pre-agreed, and the above example does not constitute a limitation on the present invention.

[0047] Step S203: The game server responds to the test command for the target game from the game client and logs in at least one subordinate robot object corresponding to the target protagonist object in the target game. The target protagonist object is the player character object logged in in the game client.

[0048] In one implementation, step S203 includes: step S2031, responding to a test instruction from the game client for the target game, determining the number of target robots indicated by the test instruction, and generating robot object information for the number of target robots to obtain a target robot object list; step S2032, starting the test process corresponding to the target protagonist object, and logging all robot objects in the target robot object list into the target game through the test process; step S2033, binding the subordinate relationship between the target protagonist object and the target robot object list in the target game to obtain at least one subordinate robot object corresponding to the target protagonist object. It is understood that the testing process can be started on the game server or on the testing server. In this embodiment, the testing process is started on the game server. Each target protagonist object corresponds to one testing process. Each testing process creates all subordinate robot objects corresponding to the target protagonist object. For example, target protagonist object A corresponds to testing process a, and testing process a creates all subordinate robot objects A1-A4 corresponding to target protagonist object A. Target protagonist object A and subordinate robot objects A1-A4 are bound to a subordinate relationship on the game server. The storage format for this subordinate relationship can be {key = target protagonist object A, value = [subordinate robot object A1, subordinate robot object A2, subordinate robot object A3, subordinate robot object A4]}, but the specific format is not limited here. In this embodiment, the number of subordinate robot objects that the testing process needs to log in is indicated by the testing command. The testing command contains robot information input by the game client through the testing control. The robot information includes the target robot count. The testing command sends the robot information to the game server, which can then determine the target robot count and generate robot object information for that target robot count, thus obtaining a target robot object list. For example, if a tester enters 5 target robots in the game client, the game server will create 5 robot object information and obtain a target robot object list. The target robot object list contains information about 5 robot objects. The robot object information may include robot name, robot player character attributes, robot number, etc., but the specifics are not limited here.

[0049] In one implementation, step S2031 includes: responding to a test command from a game client for a target game, obtaining the number of target robots indicated by the test command; determining whether the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, wherein the number of bound robot objects indicates the number of robot objects in the list of bound robot objects corresponding to the target protagonist object; if the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, calculating the difference between the number of bound robot objects and the number of target robots, and creating robot object information for the difference number to obtain a list of robot objects to be bound; combining the list of bound robot objects and the list of robot objects to be bound to obtain a list of target robot objects. In one implementation, after determining whether the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, the method further includes: if the number of bound robot objects corresponding to the target protagonist object is greater than or equal to the number of target robots, obtaining robot object information for the number of target robots from the list of bound robot objects corresponding to the target protagonist object to obtain a list of target robot objects.

[0050] Understandably, since subordinate robot objects have the same player status in the target game as real player objects, their game history can also be saved just like that of real players. After logging into the target game, subordinate robot objects can also access their game history and start playing. Based on this, the robot objects bound to the target protagonist will not be deleted after the test ends. When the game server responds to the test command, it can first check whether the target protagonist has a corresponding list of bound robot objects. If it does, when generating the target robot object list, it first determines whether the number of robot objects in the list of bound robot objects is greater than or equal to the number of target robots indicated by the test command. If not, it creates the missing number of robot objects. If so, it means that there is no need to create robot objects again, and the robot object information for the target number of robots can be directly obtained from the list of bound robot objects. The subordinate robot object logs in to the target game using the robot object information in the list of bound robot objects. The actual login is the player account with game history, which allows the subordinate robot object to also call the game history in the target game and start the game directly. This reduces the loss of game character records during the game test, making the game test more comprehensive and the behavior of the test robot closer to that of a real player.

[0051] In one implementation, step S2032 includes: starting the test process corresponding to the target protagonist object, and determining whether each robot object in the target robot object list has a corresponding player character object; if any robot object in the target robot object list does not have a corresponding player character object, then creating player character objects corresponding to all robot objects, thus obtaining player character objects corresponding to each robot object in the target robot object list; based on the player character objects corresponding to each robot object in the target robot object list, establishing a connection between each robot object and the target game through the test process, thus obtaining all robot objects logged into the target robot object list in the target game. In this implementation, since subordinate robot objects can also access the game history of the target game, for robot objects created for the first time, i.e., logging into the target game for the first time, the game logic for creating player character objects needs to be executed first, and then the game process of the target game in the game server needs to be connected based on the corresponding created player character objects to log into all robot objects, making the game testing process more automated.

[0052] Step S204: The game server responds to the player's action operation on the target protagonist object by determining whether the player's action operation hits any preset non-complete follow operation;

[0053] In one implementation, step S204 includes: responding to a player action operation targeting a target protagonist object sent by the game client through a target game communication protocol function, obtaining protagonist protocol parameters and robot protocol parameters from the target game communication protocol function. The protagonist protocol parameters are used to indicate the communication protocol parameters for the player action operation of the target protagonist object, and the robot protocol parameters are used to indicate the communication protocol parameters for the follow operation of each subordinate robot object. The protagonist protocol parameters include protagonist action parameters, and the robot protocol parameters include a follow action identifier and protagonist action parameters. The protagonist action parameters include a protagonist action identifier. A preset incomplete follow operation list is obtained, and it is determined whether the preset incomplete follow operation list contains a protagonist action identifier, so as to determine whether the player action operation hits any preset incomplete follow operation. In this implementation, after the game server receives the player action operation targeting the target protagonist object sent by the game client through the target game communication protocol function, it obtains the protagonist protocol parameters and robot protocol parameters by parsing the target game communication protocol function. As an example, and not a limitation, let's assume the target game's communication protocol function contains: "send(BUY_GOODS, [DOODS_ID]); send(COPY_ACTION, [BUY_GOODS, [DOODS_ID]])". Here, "BUY_GOODS" is the protagonist's behavior identifier in the protagonist's behavior parameters, "[DOODS_ID]" is the specific behavior parameter in the protagonist's behavior parameters, and "COPY_ACTION" is the follow behavior identifier. The specifics are not limited here. Based on the protagonist's behavior identifier BUY_GOODS in the target game's communication protocol function, it can be determined whether the preset incomplete follow operation list contains the protagonist's behavior identifier BUY_GOODS, thus determining whether the player's behavior operation hits any preset incomplete follow operation. This makes the test bot's behavior execution logic in the target game identical to that of a real player, easily driving the bot's behavior and facilitating related game testing without needing to write bot execution scripts / programs.

[0054] Step S205: If the player's action hits any preset incomplete follow operation, the game server executes the game logic corresponding to the hit incomplete follow operation on each subordinate robot object to obtain a first execution result. The first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal.

[0055] In one implementation, step S205 includes: if a preset list of incomplete follow operations contains a protagonist behavior identifier, then determine that the player behavior operation hits any preset incomplete follow operation; determine the incomplete follow operation function corresponding to the protagonist behavior identifier through robot protocol parameters, and execute the incomplete follow operation function corresponding to the protagonist behavior identifier for each subordinate robot object to obtain a first execution result. The incomplete follow operation function corresponding to the protagonist behavior identifier is an interactive behavior operation function or a player behavior operation function that eliminates complete follow obstacles. The incomplete follow operation function is used to indicate the game logic corresponding to the hit incomplete follow operation. In this implementation, the incomplete follow operation function can be pre-associated with the protagonist behavior identifier. When the preset list of incomplete follow operations contains a protagonist behavior identifier corresponding to the player behavior operation, the game server instructs each subordinate robot object to execute the incomplete follow operation function corresponding to the protagonist behavior identifier, thereby obtaining the first execution result. For example, suppose the player action is "Request to add friend", and the protagonist's action identifier for "Request to add friend" is "APPLY_FRIEND". This player action is a non-complete follow operation. When the target protagonist object performs the "Request to add friend" player action, we want the subordinate robot object to perform the "Reply to add friend" non-complete follow operation. Then, "APPLY_FRIEND" can be pre-bound to the "Reply to add friend" function robot_reply_firend_func. When the target protagonist object performs the "Request to add friend" player action, the subordinate robot object executes robot_reply_firend_func, responds to the target protagonist object's "Request to add friend", and adds the target protagonist object as a friend, thereby implementing the game logic of the "Reply to add friend" function.

[0056] It should be noted that, generally speaking, operations that require interactive behavior testing, as well as operations that require the removal of obstacles to complete following, are preset as non-complete following operations. In other words, the preset non-complete following operations are used to indicate interactive behavior operations or player behavior operations that require the removal of obstacles to complete following. For example, the interactive behavior operations of "responding to add friends" and "joining the team" in the above example are operations that require interactive behavior testing. The behavior requiring the removal of complete follow obstacles refers to operations that subordinate robot objects cannot perform without removing the complete follow obstacles. For example, if a player's action is to "claim an exclusive item," the subordinate robot object cannot directly claim it because the player is claiming an "exclusive item." The exclusiveness of the item needs to be removed, or an identical exclusive item needs to be created for the subordinate robot object before it can perform the "claim exclusive item" operation. This is a player behavior operation requiring the removal of complete follow obstacles, which can be executed through a function for removing complete follow obstacles. For example, a function for removing complete follow obstacles would first create an "exclusive item" for the subordinate robot object, and then allow the subordinate robot object to claim the created "exclusive item," thus completing the testing of non-complete follow operation functions and making the game testing process more automated and intelligent.

[0057] Step S206: If the player's action does not hit the preset non-complete follow operation, the game server executes the game logic corresponding to the player's action for each subordinate robot object to obtain a second execution result. The second execution result is used to indicate whether the game logic corresponding to the player's action is normal.

[0058] In one implementation, step S206 includes: if the preset incomplete follow operation list does not contain the protagonist behavior identifier, then it is determined that the player behavior operation has not matched the preset incomplete follow operation; the player behavior operation function corresponding to the protagonist behavior identifier is determined through robot protocol parameters, and the player behavior operation function corresponding to the protagonist behavior identifier is executed for each subordinate robot object to obtain a first execution result. The player behavior operation function is used to indicate the game logic corresponding to the player behavior operation. In this implementation, if the preset incomplete follow operation list does not contain the protagonist behavior identifier, it means that the player behavior operation has not matched the preset incomplete follow operation. In this case, the test can be completed by executing the player behavior operation function corresponding to the protagonist behavior identifier for all subordinate robot objects.

[0059] The game testing method provided by the above implementation allows the game client to configure different robot information and submit it to the game server. The game server drives at least one subordinate robot object to fully or partially follow the behavior of the protagonist object through the player's operation behavior. By presetting different partial follow operations, the subordinate robot object can be made to execute game logic different from the protagonist object's behavior. It can also be made to execute the same game logic as the protagonist object's behavior according to the test requirements. Thus, the game logic test can be completed efficiently without writing test scripts / programs. It has a high degree of configurability and reduces the complexity of game logic testing.

[0060] Please see Figure 3 Another embodiment of the game testing method in this invention includes:

[0061] Step S301: The game server responds to the test command for the target game from the game client and logs in at least one subordinate robot object corresponding to the target protagonist object in the target game. The target protagonist object is the player character object logged in in the game client.

[0062] Step S302: The game server responds to the player's action operation on the target protagonist object by determining whether the player's action operation hits any preset non-complete follow operation;

[0063] Step S303: If the player's action hits any preset incomplete follow operation, the game server executes the game logic corresponding to the hit incomplete follow operation on each subordinate robot object to obtain the first execution result. The first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal.

[0064] Step S304: If the player's action does not hit the preset non-complete follow operation, the game server executes the game logic corresponding to the player's action for each subordinate robot object to obtain a second execution result. The second execution result is used to indicate whether the game logic corresponding to the player's action is normal.

[0065] The execution process of steps S301-S304 is similar to that of steps S10-S40, and will not be described in detail here.

[0066] Step S305: The test server responds to the robot login command of the game server for the target game and starts the test process corresponding to the robot login command. The robot login command includes the object information of the target protagonist object and the robot information.

[0067] In this embodiment, after responding to the game client's test command for the target game, the game server sends a robot login command to the test server, instructing the test server to log robot objects into the target game. When sending the robot login command, the game server carries the robot information submitted by the game client and the object information of the target protagonist object. In response to the robot login command, the test server starts a test process corresponding to the target protagonist object, used for batch login of at least one subordinate robot object corresponding to the target protagonist object. It should be noted that one test process corresponds to one target protagonist object. Target protagonist objects logged in by different game clients can have different test processes started on the test server, allowing robot objects to better follow the behavior of a protagonist object and preventing behavior tracking confusion.

[0068] Step S306: The test server creates at least one subordinate robot object corresponding to the target protagonist object through the test process, and establishes a connection between each subordinate robot object and the game server, thereby obtaining at least one subordinate robot object corresponding to the target protagonist object logged in the target game. The target protagonist object is the player character object logged in in the game client.

[0069] Understandably, the test server is primarily used to simulate the login of at least one subordinate robot object to a game client in the target game. This ensures that the robot object's behavior in the target game mirrors that of a real player logged into a real game client, thereby better testing the game logic. In this implementation, after the test process on the test server creates at least one subordinate robot object corresponding to the target protagonist object, it establishes a network connection with the game server at a specified IP and port on a per-subordinate robot object basis, thus completing the login and obtaining at least one subordinate robot object corresponding to the target protagonist object logged into the target game. This implementation separates the execution flow of the robot object simulating the game client's login to the target game from the game server, enabling the test server to test different virtual games. Furthermore, it reduces the game server load while decoupling some test procedures, making game testing more efficient and convenient.

[0070] In one embodiment, the robot login instruction further includes the game server's address information, and the robot information includes the number of target robots. Step S306 includes: generating robot object information for the target robot number based on the target robot number, obtaining a target robot object list; establishing connections between all robot objects in the target robot object list and the game server through a test process based on the game server's address information, thereby obtaining at least one subordinate robot object corresponding to the target protagonist object logged into the game server. In this embodiment, the robot login instruction also carries the game server's address information, namely the game server's IP address and port number, as well as the number of target robots. When the test server logs in a subordinate robot object, it establishes a connection between each subordinate robot object and the game server based on the game server's IP address and port number, thereby obtaining at least one subordinate robot object corresponding to the target protagonist object logged into the game server. The specific number of logged-in subordinate robot objects depends on the number of target robots, and is not limited here.

[0071] In one implementation, the robot information includes the target login duration for each robot object; after step S306 above, the following is also included:

[0072] Step S1: Within each preset time segment, check whether the connection between the game server and the test process is normal, and determine whether the robot login time exceeds the target login time. The robot login time is used to indicate the difference between the login time of the subordinate robot object on the game server and the current time.

[0073] Step S2: If the connection between the game server and the test process is normal, and the robot's login time does not exceed the target login time, the test process will be put into sleep mode during the remaining time segment. At the beginning of the next preset time segment, the test process will be woken up and Step S1 will be repeated until the connection between the game server and the test process is abnormal, or the robot's login time exceeds the target login time. The remaining time segment is used to indicate the time from the end of the execution of Step S1 to the end of the corresponding preset time segment.

[0074] It should be noted that the test process can also manage the lifecycle of each subordinate robot object, as well as the lifecycle management of the test process itself. Specifically, in this embodiment, time is first divided into time segments of a preset size, and a lifecycle management loop is executed within each preset time segment. For example, one second is divided into 10 time segments, each of which can be called a frame. The size of each preset time segment is 1000 / 10 = 100 milliseconds. One lifecycle management loop is executed within each 100 milliseconds. One lifecycle management loop includes: checking whether the connection between the game server and the test process is normal, and determining whether the robot login time exceeds the target login time. After execution, the test process can enter a sleep state during the remaining time segments, waiting for the next loop to arrive. When the next loop arrives, the test process is awakened, and one lifecycle management loop is executed repeatedly until an abnormal connection between the game server and the test process is detected, or the robot login time exceeds the target login time. At this point, the test process ends, and the game test is completed. For example, assuming a lifecycle management loop ends at 30 milliseconds within a 100-millisecond timeframe, the test process enters a sleep state for the remaining 70 milliseconds. After 70 milliseconds, which is the end of the preset 100-millisecond time segment, the test process is woken up again to begin the next 100-millisecond lifecycle management loop. This continues until a connection anomaly is detected between the game server and the test process, or the bot's login duration exceeds the target login duration. At this point, the test process terminates, the game test is complete, and all subordinate bot objects are exited from the game server. It's understandable that the target login duration can also be set through test controls in the game client to indicate the login duration for each subordinate bot object.

[0075] In one implementation, checking the connection between the game server and the test process includes: checking whether the game server receives a heartbeat protocol periodically sent by the game client; checking whether the game server receives a network disconnection protocol sent by the game client; and checking whether the game server receives a login logout protocol sent by the game client. Here, the login logout protocol refers to the protocol that causes the currently logged-in game client to log off when the target character logs in on another game client.

[0076] The game testing method provided by the above implementation method simulates a game client logging into a robot object on the game server through a test server. The game server drives at least one subordinate robot object to fully or partially follow the behavior of the protagonist object through the player's operation behavior. By preset different partial follow operations, the subordinate robot object can be made to execute game logic different from the protagonist object's behavior. It can also be made to execute the same game logic as the protagonist object's behavior according to the test requirements. Thus, game logic testing can be completed efficiently without writing test scripts / programs, reducing the complexity of game logic testing. The decoupled test server can also be used for testing different virtual games, thus expanding the application scenarios.

[0077] For the corresponding method embodiments described above, see [link to relevant documentation]. Figure 4 The diagram illustrates a game testing device applied to a game server. The device includes: a robot login module 40, configured to log at least one subordinate robot object corresponding to a target protagonist object in the target game in response to a test command from a game client for a target game; the target protagonist object being a player character object logged into the game client; a first judgment module 42, configured to determine whether a player behavior operation on the target protagonist object, in response to a player behavior operation from the game client, hits any preset incomplete follow operation; a first execution module 44, configured to execute the game logic corresponding to the hit incomplete follow operation on each subordinate robot object if the player behavior operation hits any preset incomplete follow operation, obtaining a first execution result, the first execution result indicating whether the game logic corresponding to the hit incomplete follow operation is normal; and a second execution module 46, configured to execute the game logic corresponding to the player behavior operation on each subordinate robot object if the player behavior operation does not hit any preset incomplete follow operation, obtaining a second execution result, the second execution result indicating whether the game logic corresponding to the player behavior operation is normal.

[0078] The aforementioned game testing device drives at least one subordinate robot object to fully or partially follow the player's actions based on the player's actions on the main character object. By presetting different partial follow operations, the subordinate robot object can execute game logic different from the main character object's behavior. Alternatively, it can execute the same game logic as the main character object's behavior according to testing requirements. This allows for efficient testing of game logic without the need to write test scripts / programs, reducing the complexity of game logic testing.

[0079] Optionally, the first judgment module 42 is specifically used to: respond to the player behavior operation for the target protagonist object sent by the game client through the target game communication protocol function, obtain the protagonist protocol parameters and robot protocol parameters in the target game communication protocol function, wherein the protagonist protocol parameters are used to indicate the communication protocol parameters of the player behavior operation of the target protagonist object, and the robot protocol parameters are used to indicate the communication protocol parameters of the follow operation of each subordinate robot object, wherein the protagonist protocol parameters include protagonist behavior parameters, and the robot protocol parameters include follow behavior identifier and protagonist behavior parameters, wherein the protagonist behavior parameters include protagonist behavior identifier; obtain a preset incomplete follow operation list, and determine whether the preset incomplete follow operation list contains the protagonist behavior identifier, so as to determine whether the player behavior operation hits any preset incomplete follow operation.

[0080] Optionally, the first execution module 44 is specifically used to: if the preset list of incomplete follow operations contains the protagonist behavior identifier, determine that the player behavior operation hits any preset incomplete follow operation; determine the incomplete follow operation function corresponding to the protagonist behavior identifier through the robot protocol parameters, and execute the incomplete follow operation function corresponding to the protagonist behavior identifier for each subordinate robot object to obtain a first execution result, wherein the incomplete follow operation function corresponding to the protagonist behavior identifier is an interactive behavior operation function or a player behavior operation function that eliminates complete follow obstacles, and the incomplete follow operation function is used to indicate the game logic corresponding to the hit incomplete follow operation.

[0081] Optionally, the second execution module 46 is specifically used to: if the preset non-complete follow operation list does not contain the protagonist behavior identifier, determine that the player behavior operation has not hit the preset non-complete follow operation; determine the player behavior operation function corresponding to the protagonist behavior identifier through the robot protocol parameters, and execute the player behavior operation function corresponding to the protagonist behavior identifier for each subordinate robot object to obtain a first execution result, wherein the player behavior operation function is used to indicate the game logic corresponding to the player behavior operation.

[0082] Optionally, the robot login module 40 includes: a generation unit, configured to respond to a test instruction from a game client for a target game, determine the number of target robots indicated by the test instruction, and generate robot object information for the number of target robots to obtain a target robot object list; a login unit, configured to start a test process corresponding to a target protagonist object, and log in all robot objects in the target robot object list in the target game through the test process; and a binding unit, configured to bind the subordinate relationship between the target protagonist object and the target robot object list in the target game to obtain at least one subordinate robot object corresponding to the target protagonist object.

[0083] Optionally, the above-mentioned generation unit is specifically used for: responding to a test instruction from the game client for the target game, obtaining the number of target robots indicated by the test instruction; determining whether the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, wherein the number of bound robot objects is used to indicate the number of robot objects in the list of bound robot objects corresponding to the target protagonist object; if the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, calculating the difference between the number of bound robot objects and the number of target robots, and creating robot object information for the difference number to obtain a list of robot objects to be bound; and combining the list of bound robot objects and the list of robot objects to be bound to obtain a list of target robot objects.

[0084] Optionally, the above device further includes: an acquisition module, configured to, if the number of bound robot objects corresponding to the target protagonist object is greater than or equal to the number of target robots, acquire robot object information of the target robot number from the list of bound robot objects corresponding to the target protagonist object, and obtain a target robot object list.

[0085] Optionally, the login unit described above is specifically used to: initiate a test process corresponding to the target protagonist object, and determine whether each robot object in the target robot object list has a corresponding player character object; if any robot object in the target robot object list does not have a corresponding player character object, then create player character objects corresponding to all any robot objects, thereby obtaining a player character object corresponding to each robot object in the target robot object list; based on the player character object corresponding to each robot object in the target robot object list, establish a connection between each robot object and the target game through the test process, thereby obtaining all robot objects logged into the target robot object list in the target game.

[0086] For the corresponding method embodiments described above, see [link to relevant documentation]. Figure 5The diagram shows another game testing device applied to a game client. The game client provides a graphical user interface (GUI) displaying test controls. The device includes: an instruction sending module 50, used to send a test instruction to a target game in response to the submission of robot information input through the test controls. The test instruction includes the input robot information, which indicates parameters of at least one subordinate robot object corresponding to the target protagonist object logged in the target game; and a hot update module 52, used to hot update the game communication protocol function in the game client in response to the successful execution of the robot login instruction corresponding to the test instruction, to obtain a target game communication protocol function in the game client. The target game communication protocol function indicates the communication protocol parameters for player behavior operations of the target protagonist object and the communication protocol parameters for follow operations of subordinate robot objects. The follow operation includes a preset incomplete follow operation and a preset complete follow operation. The target game communication protocol function is used to communicate with the target game.

[0087] In the aforementioned game testing device, the game client can be configured to submit different robot information to the game server. The game server drives at least one subordinate robot object to fully or partially follow the behavior of the protagonist object based on the player's operation behavior. By presetting different partial follow operations, the subordinate robot object can be made to execute game logic different from the protagonist object's behavior. It can also be made to execute the same game logic as the protagonist object's behavior according to the test requirements. Thus, game logic testing can be completed efficiently without writing test scripts / programs. It has a high degree of configurability and reduces the complexity of game logic testing.

[0088] For the corresponding method embodiments described above, see [link to relevant documentation]. Figure 6 The diagram shows another game testing device applied to a test server. The device includes: a process startup module 60, used to start a test process corresponding to a robot login command for a target game in response to a robot login command from the game server. The robot login command includes object information of the target protagonist object and robot information. A connection establishment module 62 is used to create at least one subordinate robot object corresponding to the target protagonist object through the test process, and establish a connection between each subordinate robot object and the game server, thereby obtaining at least one subordinate robot object corresponding to the target protagonist object logged in the target game. The target protagonist object is a player character object logged in in the game client.

[0089] The aforementioned game testing device simulates a game client logging into a robot object on a game server via a test server. The game server drives at least one subordinate robot object to fully or partially follow the protagonist's behavior based on the player's actions. By pre-setting different partial follow operations, the subordinate robot object can execute game logic different from the protagonist's behavior. Alternatively, it can execute the same game logic as the protagonist's behavior according to testing requirements. This allows for efficient testing of game logic without writing test scripts / programs, reducing the complexity of game logic testing. The decoupled test server can also be used for testing different virtual games, expanding the application scenarios.

[0090] Optionally, the robot login instruction further includes the address information of the game server, and the robot information includes the number of target robots; the connection establishment module 62 is specifically used to: generate robot object information for the number of target robots according to the number of target robots, to obtain a list of target robot objects; based on the address information of the game server, establish a connection between all robot objects in the list of target robot objects and the game server through the test process, to obtain at least one subordinate robot object corresponding to the target protagonist object logged in on the game server.

[0091] Optionally, the robot information includes the target login duration for each robot object; the device further includes: a checking module, used to check whether the connection between the game server and the test process is normal within each preset time segment, and to determine whether the robot login duration exceeds the target login duration, wherein the robot login duration is used to indicate the difference between the login time of the subordinate robot object on the game server and the current time; a hibernation module, used to, if the connection between the game server and the test process is normal and the robot login duration does not exceed the target login duration, put the test process into hibernation within the remaining time segment, and wake up the test process at the beginning of the next preset time segment, repeating the checking module until the connection between the game server and the test process is abnormal, or the robot login duration exceeds the target login duration, wherein the remaining time segment is used to indicate the execution end time of the checking module to the end time of the corresponding preset time segment.

[0092] This embodiment also provides an electronic device, including a processor and a memory. The memory stores machine-executable instructions that can be executed by the processor, and the processor executes the machine-executable instructions to implement the above-described game testing method. This electronic device can be a server or a terminal device.

[0093] See Figure 7As shown, the electronic device includes a processor 700 and a memory 701. The memory 701 stores machine-executable instructions that can be executed by the processor 700. The processor 700 executes the machine-executable instructions to implement the above-described game testing method.

[0094] Furthermore, Figure 7 The electronic device shown also includes a bus 702 and a communication interface 703. The processor 700, the communication interface 703, and the memory 701 are connected via the bus 702.

[0095] The memory 701 may include high-speed random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 703 (which can be wired or wireless), such as the Internet, wide area network, local area network, or metropolitan area network. The bus 702 may be an ISA bus, PCI bus, or EISA bus, etc. The bus can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 7 The symbol is represented by a single double-headed arrow, but this does not mean that there is only one bus or one type of bus.

[0096] The processor 700 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of the processor 700 or by instructions in software form. The processor 700 may be a general-purpose processor, including a Central Processing Unit (CPU), a Network Processor (NP), etc.; it may also be a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field-Programmable Gate Array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this invention. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this invention can be directly manifested as execution by a hardware decoding processor, or execution by a combination of hardware and software modules in the decoding processor. The software module can reside in a readily available storage medium in the art, such as random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, or registers. This storage medium is located in memory 701. The processor 700 reads information from memory 701 and, in conjunction with its hardware, completes the steps of the method described in the foregoing embodiments.

[0097] This embodiment also provides a computer-readable storage medium storing computer-executable instructions. When the computer-executable instructions are called and executed by a processor, the computer-executable instructions cause the processor to implement the above-described game testing method.

[0098] The computer program products of the game testing method, apparatus, electronic device and storage medium provided in the embodiments of the present invention include a computer-readable storage medium storing program code. The instructions included in the program code can be used to execute the methods described in the preceding method embodiments. For specific implementation, please refer to the method embodiments, which will not be repeated here.

[0099] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the system and apparatus described above can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0100] Furthermore, in the description of the embodiments of the present invention, unless otherwise explicitly specified and limited, the terms "installation," "connection," and "linking" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; they can refer to a mechanical connection or an electrical connection; they can refer to a direct connection or an indirect connection through an intermediate medium; and they can refer to the internal connection of two components. Those skilled in the art can understand the specific meaning of the above terms in the present invention based on the specific circumstances.

[0101] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0102] In the description of this invention, it should be noted that the terms "center," "upper," "lower," "left," "right," "vertical," "horizontal," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are used only for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on the invention. Furthermore, the terms "first," "second," and "third" are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0103] Finally, it should be noted that the above embodiments are merely specific implementations of the present invention, used to illustrate the technical solutions of the present invention, and not to limit it. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the technical scope disclosed in the present invention, or make equivalent substitutions for some of the technical features; and these modifications, changes, 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, and should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A game testing method, characterized in that, Applied to a game server, the method includes: In response to a test command from the game client for a target game, at least one subordinate robot object corresponding to a target protagonist object is logged into the target game, wherein the target protagonist object is a player character object logged into the game client; In response to the player's action on the target protagonist object by the game client, it is determined whether the player's action hits any preset non-complete follow operation; the hit is determined based on whether the preset non-complete follow operation list contains the protagonist action identifier. The complete follow operation is used to instruct the subordinate robot object to perform the same player action as the target protagonist object. Anything other than the complete follow operation is a non-complete follow operation. If the player's action hits any preset incomplete follow operation, then the game logic corresponding to the hit incomplete follow operation is executed for each subordinate robot object to obtain a first execution result. The first execution result is used to indicate whether the game logic corresponding to the hit incomplete follow operation is normal. If the player's action does not match the preset non-complete follow operation, the game logic corresponding to the player's action is executed for each subordinate robot object to obtain a second execution result. The second execution result is used to indicate whether the game logic corresponding to the player's action is normal.

2. The method according to claim 1, characterized in that, The step of responding to player behavior operations on the target character object in the game client, and determining whether the player behavior operation matches any preset non-complete follow operation, includes: In response to a player action operation for the target protagonist object sent by the game client through a target game communication protocol function, the protagonist protocol parameters and robot protocol parameters in the target game communication protocol function are obtained. The protagonist protocol parameters are used to indicate the communication protocol parameters for the player action operation of the target protagonist object, and the robot protocol parameters are used to indicate the communication protocol parameters for the follow operation of each subordinate robot object. The protagonist protocol parameters include protagonist action parameters, and the robot protocol parameters include a follow action identifier and protagonist action parameters. The protagonist action parameters include a protagonist action identifier. Obtain a preset list of incomplete follow operations, and determine whether the preset list of incomplete follow operations contains the protagonist's behavior identifier, so as to determine whether the player's behavior operation hits any preset incomplete follow operation.

3. The method according to claim 2, characterized in that, If the player's action hits any preset incomplete follow operation, then the game logic corresponding to the hit incomplete follow operation is executed for each subordinate robot object to obtain a first execution result, including: If the preset incomplete follow operation list contains the protagonist behavior identifier, then it is determined that the player behavior operation hits any preset incomplete follow operation; The non-complete follow operation function corresponding to the protagonist behavior identifier is determined by the robot protocol parameters, and the non-complete follow operation function corresponding to the protagonist behavior identifier is executed for each subordinate robot object to obtain a first execution result. The non-complete follow operation function corresponding to the protagonist behavior identifier is an interactive behavior operation function or a player behavior operation function that eliminates the obstacle of complete follow. The non-complete follow operation function is used to indicate the game logic corresponding to the hit non-complete follow operation.

4. The method according to claim 2, characterized in that, If the player's action does not match the preset incomplete follow operation, then the game logic corresponding to the player's action is executed for each subordinate robot object to obtain a second execution result, including: If the protagonist's behavior identifier is not included in the preset incomplete follow operation list, then it is determined that the player's behavior operation did not match the preset incomplete follow operation. The player behavior operation function corresponding to the protagonist behavior identifier is determined by the robot protocol parameters, and the player behavior operation function corresponding to the protagonist behavior identifier is executed for each subordinate robot object to obtain a first execution result. The player behavior operation function is used to indicate the game logic corresponding to the player behavior operation.

5. The method according to claim 1, characterized in that, The step of responding to a test command from a game client for a target game, and logging at least one subordinate robot object corresponding to the target protagonist object in the target game, includes: In response to a test command from the game client for the target game, determine the number of target robots indicated by the test command, generate robot object information for the number of target robots, and obtain a list of target robot objects; Start the test process corresponding to the target protagonist object, and log all robot objects in the target robot object list in the target game through the test process; In the target game, the subordinate relationship between the target protagonist object and the target robot object list is bound to obtain at least one subordinate robot object corresponding to the target protagonist object.

6. The method according to claim 5, characterized in that, In response to a test command from the game client for the target game, the number of target robots indicated by the test command is determined, and robot object information for that number of target robots is generated, resulting in a list of target robot objects, including: In response to a test command from the game client for the target game, obtain the number of target robots indicated by the test command; Determine whether the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, wherein the number of bound robot objects is used to indicate the number of robot objects in the list of bound robot objects corresponding to the target protagonist object; If the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, then calculate the difference between the number of bound robot objects and the number of target robots, and create robot object information for the difference number to obtain a list of robot objects to be bound. By combining the list of already bound robot objects and the list of robot objects to be bound, a target robot object list is obtained.

7. The method according to claim 6, characterized in that, After determining whether the number of bound robot objects corresponding to the target protagonist object is less than the number of target robots, the method further includes: If the number of bound robot objects corresponding to the target protagonist object is greater than or equal to the number of target robots, then the robot object information of the target robot number is obtained from the list of bound robot objects corresponding to the target protagonist object, thus obtaining the target robot object list.

8. The method according to claim 5, characterized in that, The process of launching the test process corresponding to the target protagonist object, and logging all robot objects in the target robot object list into the target game through the test process, includes: Initiate the test process corresponding to the target protagonist object, and determine whether each robot object in the target robot object list has a corresponding player character object; If no corresponding player character object exists for any robot object in the target robot object list, then player character objects corresponding to all any robot objects are created, thus obtaining a player character object corresponding to each robot object in the target robot object list. Based on the player character object corresponding to each robot object in the target robot object list, a connection between each robot object and the target game is established through the testing process, thereby obtaining all robot objects logged into the target game from the target robot object list.

9. A game testing device, characterized in that, The device, used in a game server, includes: The robot login module is used to respond to the test command of the game client for the target game and log at least one subordinate robot object corresponding to the target protagonist object in the target game, wherein the target protagonist object is the player character object logged in in the game client; The first judgment module is used to respond to the player behavior operation of the game client on the target protagonist object and determine whether the player behavior operation hits any preset non-complete follow operation; the hit is determined based on whether the preset non-complete follow operation list contains the protagonist behavior identifier. The complete follow operation is used to instruct the subordinate robot object to perform the same player behavior operation as the target protagonist object. The non-complete follow operation is the one other than the complete follow operation. The first execution module is used to execute the game logic corresponding to the hit non-complete follow operation for each subordinate robot object if the player's behavior operation hits any preset non-complete follow operation, and obtain a first execution result. The first execution result is used to indicate whether the game logic corresponding to the hit non-complete follow operation is normal. The second execution module is used to execute the game logic corresponding to the player's behavior operation for each subordinate robot object if the player's behavior operation does not hit the preset non-complete follow operation, and obtain a second execution result. The second execution result is used to indicate whether the game logic corresponding to the player's behavior operation is normal.

10. An electronic device, characterized in that, It includes a processor and a memory, the memory storing machine-executable instructions that can be executed by the processor, the processor executing the machine-executable instructions to implement the game testing method according to any one of claims 1-8.

11. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when invoked and executed by a processor, cause the processor to implement the game testing method according to any one of claims 1-8.

Images