CN116225942A - Game engine development test system based on operation analysis - Google Patents
Game engine development test system based on operation analysis Download PDFInfo
- Publication number
- CN116225942A CN116225942A CN202310213068.7A CN202310213068A CN116225942A CN 116225942 A CN116225942 A CN 116225942A CN 202310213068 A CN202310213068 A CN 202310213068A CN 116225942 A CN116225942 A CN 116225942A
- Authority
- CN
- China
- Prior art keywords
- game engine
- node
- test
- development
- module
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000011981 development test Methods 0.000 title claims abstract description 20
- 238000012360 testing method Methods 0.000 claims abstract description 121
- 238000004422 calculation algorithm Methods 0.000 claims abstract description 49
- 238000011161 development Methods 0.000 claims abstract description 44
- 238000013500 data storage Methods 0.000 claims abstract description 9
- 238000000034 method Methods 0.000 claims abstract description 9
- 230000003993 interaction Effects 0.000 claims abstract description 8
- 230000006870 function Effects 0.000 claims description 36
- 230000035772 mutation Effects 0.000 claims description 18
- 238000007726 management method Methods 0.000 claims description 7
- 230000003044 adaptive effect Effects 0.000 claims description 6
- 230000008569 process Effects 0.000 claims description 5
- 238000005457 optimization Methods 0.000 claims description 4
- 238000009877 rendering Methods 0.000 claims description 4
- 208000001613 Gambling Diseases 0.000 claims description 3
- 238000013473 artificial intelligence Methods 0.000 claims description 3
- 238000011990 functional testing Methods 0.000 claims description 3
- 238000001514 detection method Methods 0.000 description 5
- 230000000694 effects Effects 0.000 description 2
- 230000004044 response Effects 0.000 description 2
- 238000004088 simulation Methods 0.000 description 2
- 239000002699 waste material Substances 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000005484 gravity Effects 0.000 description 1
- 238000005286 illumination Methods 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 239000002245 particle Substances 0.000 description 1
- 238000011056 performance test Methods 0.000 description 1
- 238000004904 shortening Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Software Systems (AREA)
- Debugging And Monitoring (AREA)
- Medical Treatment And Welfare Office Work (AREA)
Abstract
The invention relates to a testing method, in particular to a game engine development testing system based on operation analysis, which comprises the following steps: and a data storage module: interaction and storage for providing a data interface for game engine development test data; the engine development module: for developing a sub-portion of the game engine; and (3) an operation analysis module: the game engine subsection is used for carrying out operation analysis on the game engine subsection developed by the engine development module; the function realizing module: the method is used for summarizing sub-parts of the developed game engine to generate a complete game engine. According to the invention, the test cases are generated and the variation of the test cases is carried out on each sub-part of the generated game engine, the operation test analysis is carried out through the self-adaptive optimizing algorithm combining the A-type algorithm and the Bresenham algorithm, and the code which cannot complete the set function is returned, so that the development efficiency of developers can be effectively improved, and the user experience is improved.
Description
Technical Field
The invention relates to a testing method, in particular to a game engine development testing system based on operation analysis.
Background
The game engine is an application program component set for shortening the game development period and improving the game development efficiency, and comprises various functional module interfaces, which is the key of the game development quality. Game development is a large and complex project completed by a plurality of working species. Before the game engine appears, experts in various fields are required to spend a great deal of time and effort to complete a simple game. After the game engine appears, many functional components are packaged, so that developers do not need to face the development of the bottom layer and do not need to start from zero, and the game development efficiency is effectively improved. In recent years, a game engine is rapidly developed, and the game engine is one of hot topics of internet user access search, the code quantity involved in the development process of the game engine is redundant, the detection capability of a test case generated by the game engine development code is insufficient, and the problem mainly comes from two aspects, on one hand, the unmatched execution time of timer precision and JavaScript operation makes performance test difficult. For example, the precision of the timer in JavaScript is inconsistent in different JavaScript engines, and the current JavaScript timer with higher precision is time js, and the precision of the timer can only reach millisecond level. On the other hand, the JavaScript engine may not expose potential performance problems when performing simple operations, but as the number of operations increases, the execution efficiency of the engine becomes lower and lower, and such performance defects may be manifested when reaching a certain level. For example, when testing whether an array expansion algorithm is efficient, expansion operations need to be performed in test cases and the frequency of expansion needs to be high enough. The indiscriminate addition of loops to each statement in the test case generated by the game engine development code and the test by using the loops may lead to repeated execution of a large number of completely equivalent test cases or partial branches in the original test case may not be executed, so that the addition of a for loop to the statement in the branch has no meaning and wastes computational resources.
In order to avoid the waste of computing resources caused by invalid variation, the invention provides a game engine operation analysis test system based on an adaptive optimizing algorithm, which is used for detecting variation of test cases generated by game engine development codes, and combining an A-type algorithm with a Bresenham algorithm to generate the adaptive optimizing algorithm so as to improve the searching efficiency of the test cases and the detection efficiency of developers.
Disclosure of Invention
The object of the present invention is to solve the above-mentioned drawbacks of the background art by proposing a game engine development test system based on operation analysis.
The technical scheme adopted by the invention is as follows:
providing a game engine development test system based on a run analysis, comprising:
and a data storage module: interaction and storage for providing a data interface for game engine development test data;
the engine development module: for developing a sub-portion of the game engine;
and (3) an operation analysis module: the game engine subsection is used for carrying out operation analysis on the game engine subsection developed by the engine development module;
the function realizing module: the method is used for summarizing sub-parts of the developed game engine to generate a complete game engine.
As a preferred technical scheme of the invention: the data interface in the data storage module is used for providing a standardized data interface and various template functions, and also providing various enumeration types as key values for realizing data interaction in the development process of the game engine.
As a preferred technical scheme of the invention: the sub-parts of the engine development module include a hardware part, a development part, a scene part, and a gameplay part.
As a preferred technical scheme of the invention: the hardware part comprises an I/O interface, sound, a network and a graph; the development part comprises a development environment, script parsing and plug-ins; the scene portion includes a rendering engine and a physics engine; the gambling portion includes resource management, scene management, databases, and artificial intelligence.
As a preferred technical scheme of the invention: the operation analysis module performs operation analysis on codes generated by all the sub-parts developed in the engine development module and feeds back codes which cannot complete the established functions.
As a preferred technical scheme of the invention: and the operation analysis module adds function call to generate test cases on the basis of original function definition according to the developed game engine codes, and performs performance variation on the test cases to perform functional test.
As a preferred technical scheme of the invention: the performance variation algorithm is as follows:
s2.1: initializing an array for storing variation test cases, converting the test cases into an abstract syntax tree, and adding a root node of the abstract syntax tree into a node queue to be mutated;
s2.2: traversing each layer of nodes in the abstract syntax tree by adopting a breadth-first traversing algorithm, wherein the traversing order is from an outer layer to a memory layer by layer until no child node exists in the current node;
s2.3: searching whether the child node of the current node can add loops or not and cannot cause grammar errors, namely, the child node of the current node is of a sentence type; respectively adding loops to each sentence on the abstract syntax tree to realize mutation, generating a mutation test case for each mutation, and recovering the abstract syntax tree to the syntax tree state of the test case before mutation after the mutation test case is acquired;
s2.4: if the current node is only a common node, adding the current node into a node queue to be mutated; if it is not a node type, the mutation to the current node is ended.
As a preferred technical scheme of the invention: in S2.3, each variant test case only modifies one statement in the original test case.
As a preferred technical scheme of the invention: and the running analysis module tests the developed game engine codes through an adaptive optimization algorithm combining an A-type algorithm and a Bresenham algorithm according to the mutated test cases.
As a preferred technical scheme of the invention: the self-adaptive optimizing algorithm comprises the following steps:
s3.1: starting running test according to a developed game engine code by using a Bresenham algorithm from a START point to a target point END, storing the searched non-obstacle path nodes and sequences into a list BList1, and if no obstacle exists between the START point and the END node (test case of not completing a set function), successfully testing;
s3.2: if the obstacle node is encountered in the path searching stage by using the Bresenham algorithm, the previous node of the encountered obstacle node is recorded as a START node, the Bresenham algorithm is used for testing from the target point END to the starting point START until the obstacle is encountered, the test cases which are not the obstacle are sequentially saved in a list BList2, and the node before the first obstacle is encountered is recorded as an END node;
s3.3: searching a test case which can realize a set function between a start node and an end node by using a standard A-type algorithm, if no test case exists, failing to search a path, exiting the test case test, and if the test case exists, storing the searched test case into a list AList;
s3.4: if AList is empty, BList1 is the test case set; if AList is not empty, the sequence of test cases in BList2 is reversed, and BList1, AList and BList2 are sequentially stored in a List in turn, so that the List is a test case set.
Compared with the prior art, the game engine development test system based on operation analysis has the beneficial effects that:
according to the invention, through generating the test case for each sub-part of the generated game engine and carrying out variation of the test case, the non-executed sentences in the test case are detected and deleted, and only sentences which can be executed in the test case are reserved. The test cases after deleting the non-executed sentences are used as seed cases of performance variation, the self-adaptive optimizing algorithm combined by the A-type algorithm and the Bresenham algorithm is used for running test analysis, and codes which cannot complete the established functions are returned, so that the development efficiency of developers can be effectively improved, and the user experience is improved.
Drawings
Fig. 1 is a system block diagram of a preferred embodiment of the present invention.
The meaning of each label in the figure is: 100. a data storage module; 200. an engine development module; 300. operating an analysis module; 400. and a function realization module.
Description of the embodiments
It should be noted that, under the condition of no conflict, the embodiments of the present embodiments and features in the embodiments may be combined with each other, and the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and obviously, the described embodiments are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Referring to FIG. 1, a preferred embodiment of the present invention provides a game engine development test system based on operational analysis, comprising:
data storage module 100: interaction and storage for providing a data interface for game engine development test data;
engine development module 200: for developing a sub-portion of the game engine;
the operation analysis module 300: for performing operation analysis on the game engine sub-parts developed by the engine development module 200;
function implementation module 400: the method is used for summarizing sub-parts of the developed game engine to generate a complete game engine.
The data interface in the data storage module 100 is used for providing a standardized data interface and various template functions, and also providing various enumeration types as key values for realizing data interaction in the development process of the game engine.
The sub-parts of the engine development module 200 include a hardware part, a development part, a scene part, and a game part.
The hardware part comprises an I/O interface, sound, a network and a graph; the development part comprises a development environment, script parsing and plug-ins; the scene portion includes a rendering engine and a physics engine; the gambling portion includes resource management, scene management, databases, and artificial intelligence.
The operation analysis module 300 performs operation analysis on codes generated by the sub-parts developed in the engine development module, and feeds back codes that cannot complete the predetermined function.
The operation analysis module 300 adds function calls to generate test cases based on original function definitions according to developed game engine codes, and performs performance variation on the test cases to perform functional tests.
The performance variation algorithm is as follows:
s2.1: initializing an array for storing variation test cases, converting the test cases into an abstract syntax tree, and adding a root node of the abstract syntax tree into a node queue to be mutated;
s2.2: traversing each layer of nodes in the abstract syntax tree by adopting a breadth-first traversing algorithm, wherein the traversing order is from an outer layer to a memory layer by layer until no child node exists in the current node;
s2.3: searching whether the child node of the current node can add loops or not and cannot cause grammar errors, namely, the child node of the current node is of a sentence type; respectively adding loops to each sentence on the abstract syntax tree to realize mutation, generating a mutation test case for each mutation, and recovering the abstract syntax tree to the syntax tree state of the test case before mutation after the mutation test case is acquired;
s2.4: if the current node is only a common node, adding the current node into a node queue to be mutated; if it is not a node type, the mutation to the current node is ended.
In S2.3, each variant test case only modifies one statement in the original test case.
The operation analysis module 300 tests the developed game engine code according to the variant test case by using an adaptive optimization algorithm combining an a-algorithm and a Bresenham algorithm.
The self-adaptive optimizing algorithm comprises the following steps:
s3.1: starting running test according to a developed game engine code by using a Bresenham algorithm from a START point to a target point END, storing the searched non-obstacle path nodes and sequences into a list BList1, and if no obstacle exists between the START point and the END node (test case of not completing a set function), successfully testing;
s3.2: if the obstacle node is encountered in the path searching stage by using the Bresenham algorithm, the previous node of the encountered obstacle node is recorded as a START node, the Bresenham algorithm is used for testing from the target point END to the starting point START until the obstacle is encountered, the test cases which are not the obstacle are sequentially saved in a list BList2, and the node before the first obstacle is encountered is recorded as an END node;
s3.3: searching a test case which can realize a set function between a start node and an end node by using a standard A-type algorithm, if no test case exists, failing to search a path, exiting the test case test, and if the test case exists, storing the searched test case into a list AList;
s3.4: if AList is empty, BList1 is the test case set; if AList is not empty, the sequence of test cases in BList2 is reversed, and BList1, AList and BList2 are sequentially stored in a List in turn, so that the List is a test case set.
In this embodiment, the data storage module 100 stores various data interfaces and function types required for developing a game engine, and is capable of storing various data in the development process of the game engine. The engine development module 200 develops each sub-part of the game engine, the hardware part completes the management and use of the hardware resources by the game engine, and the development part provides support for developers to use the game engine and flexibly assemble functional components; the most core part of the game engine when the scene part is formed, and the rendering engine of the scene part comprises illumination, shadow, animation, particle special effects and the like, so that the game is a key component for showing reality and interactivity. The physics engine consists of two parts: the collision detection part is used for ensuring that the model in the virtual scene is not penetrated by the model in the virtual world, and improving the interactive reality of the scene; the physical simulation part comprises gravity, rigid physical and flexible physical, so that simulation of a virtual scene to the real world is enriched; the game part comprises game logic and a level design, and is an important part of the interesting experience of the user game. For example, in a scene, two people come to a room, the door of the room is locked, so that a character cannot trigger an event of switching into the room scene, at the moment, A asks B whether a key exists, B answers A that he has a key, A requests B to open the door of the room, the scenario pushes the character B to open the door of the room by using the key, after the door is unlocked by B, a player controls the character A to the front of the door of the cabin again, and because the cabin is unlocked, A triggers the event of switching into the room scene, so that scene conversion is realized. In this scenario, the response event is defined by: a door opening animation event, A and B dialogue event, B key animation event, door unlocking event, switching house scene event and other response events, thereby realizing dramatic expression effect of the film and dramatic stage, and improving user experience sense due to participation of interaction event.
The operation analysis module 300 performs test case generation and test case variation on the code generated by developing each sub-part, and performs operation test analysis to ensure that each generated sub-part can complete a given function. In the step of adaptive optimization algorithm combining the a-algorithm and Bresenham algorithm, collision detection is taken as an example.
Step 1 is forward Bresenham search; starting running test according to developed game engine codes by using Bresenham algorithm from a START point of code test for realizing collision detection to a final END point END of code, storing the searched codes and sequences capable of realizing code functions into a list BList1, and if no test case capable of completing the established functions exists between the START and END nodes, successfully testing;
step 2 is reverse Bresenham searching, if a test case which cannot complete the set function is encountered in a path searching stage by using a Bresenham algorithm, a previous test case which cannot complete the set function of the encountered test case is marked as a START node, the test is performed by using the Bresenham algorithm from an END point END to a START point START until the test case which cannot complete the set function is encountered, the test case which is not the test case which cannot complete the set function is sequentially stored in a list BList2, and a node before the first test case which cannot complete the set function is encountered is marked as an END node;
step 3, searching for a test case which can realize the set function between the start node and the end node by using a standard A algorithm, if no test case exists, failing to search a path, exiting the test case test, and if the test case exists, storing the searched test case into a list AList;
step 4 is a spliced code function, if AList is null, it shows that the code realizing the established function between two points can be directly searched by using Bresenham algorithm, and BList1 is a test case set; if AList is not empty, which indicates that there is an obstacle between two points, nodes in BList1 and AList are all stored in order from start point to end point, and nodes in BList2 are stored in order from target point to start point, so that the test case sequence in BList2 needs to be reversed, and then BList1, AList and BList2 are sequentially stored in List in order, then List is the test case set.
Based on the code running analysis of the running analysis module 300, the code that cannot complete the given function is returned for modification by the developer, and the function implementation module 400 synthesizes the generated sub-parts to generate a complete game engine.
It will be evident to those skilled in the art that the invention is not limited to the details of the foregoing illustrative embodiments, and that the present invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. The present embodiments are, therefore, to be considered in all respects as illustrative and not restrictive, the scope of the invention being indicated by the appended claims rather than by the foregoing description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein. Any reference sign in a claim should not be construed as limiting the claim concerned.
Furthermore, it should be understood that although the present disclosure describes embodiments, not every embodiment is provided with a separate embodiment, and that this description is provided for clarity only, and that the disclosure is not limited to the embodiments described in detail below, and that the embodiments described in the examples may be combined as appropriate to form other embodiments that will be apparent to those skilled in the art.
Claims (10)
1. The game engine development test system based on operation analysis is characterized in that: comprising the following steps:
a data storage module (100): interaction and storage for providing a data interface for game engine development test data;
engine development module (200): for developing a sub-portion of the game engine;
an operation analysis module (300): for performing a run analysis of the game engine subsection developed by the engine development module (200);
function implementation module (400): the method is used for summarizing sub-parts of the developed game engine to generate a complete game engine.
2. The running analysis based game engine development test system of claim 1, wherein: the data interface in the data storage module (100) is used for providing a standardized data interface and various template functions, and also providing various enumeration types as key values for realizing data interaction in the development process of the game engine.
3. The running analysis based game engine development test system of claim 1, wherein: the sub-parts of the engine development module (200) include a hardware part, a development part, a scene part, and a gameplay part.
4. A game engine development test system based on operational analysis according to claim 3, wherein: the hardware part comprises an I/O interface, sound, a network and a graph; the development part comprises a development environment, script parsing and plug-ins; the scene portion includes a rendering engine and a physics engine; the gambling portion includes resource management, scene management, databases, and artificial intelligence.
5. The running analysis based game engine development test system of claim 1, wherein: the operation analysis module (300) performs operation analysis on codes generated by the sub-parts developed in the engine development module, and feeds back codes incapable of completing the established functions.
6. The running analysis based game engine development test system of claim 5, wherein: the operation analysis module (300) adds function call to generate test cases on the basis of original function definition according to developed game engine codes, and performs performance variation on the test cases to perform functional test.
7. The operational analysis based game engine development test system of claim 6, wherein: the performance variation algorithm is as follows:
s2.1: initializing an array for storing variation test cases, converting the test cases into an abstract syntax tree, and adding a root node of the abstract syntax tree into a node queue to be mutated;
s2.2: traversing each layer of nodes in the abstract syntax tree by adopting a breadth-first traversing algorithm, wherein the traversing order is from an outer layer to a memory layer by layer until no child node exists in the current node;
s2.3: searching whether the child node of the current node can add loops or not and cannot cause grammar errors, namely, the child node of the current node is of a sentence type; respectively adding loops to each sentence on the abstract syntax tree to realize mutation, generating a mutation test case for each mutation, and recovering the abstract syntax tree to the syntax tree state of the test case before mutation after the mutation test case is acquired;
s2.4: if the current node is only a common node, adding the current node into a node queue to be mutated; if it is not a node type, the mutation to the current node is ended.
8. The operational analysis based game engine development test system of claim 7, wherein: in S2.3, each variant test case only modifies one statement in the original test case.
9. The running analysis based game engine development test system of claim 1, wherein: the running analysis module (300) tests the developed game engine codes through an adaptive optimization algorithm combining an A-type algorithm and a Bresenham algorithm according to the mutated test cases.
10. The running analysis based game engine development test system of claim 1, wherein: the self-adaptive optimizing algorithm comprises the following steps:
s3.1: starting running test according to the developed game engine code by using Bresenham algorithm from the START point START to the target point END, storing the searched non-obstacle path nodes and the sequence into a list BList1, and if no obstacle exists between the START point and the END node, successfully testing;
s3.2: if the obstacle node is encountered in the path searching stage by using the Bresenham algorithm, the previous node of the encountered obstacle node is recorded as a START node, the Bresenham algorithm is used for testing from the target point END to the starting point START until the obstacle is encountered, the test cases which are not the obstacle are sequentially saved in a list BList2, and the node before the first obstacle is encountered is recorded as an END node;
s3.3: searching a test case which can realize a set function between a start node and an end node by using a standard A-type algorithm, if no test case exists, failing to search a path, exiting the test case test, and if the test case exists, storing the searched test case into a list AList;
s3.4: if AList is empty, BList1 is the test case set; if AList is not empty, the sequence of test cases in BList2 is reversed, and BList1, AList and BList2 are sequentially stored in a List in turn, so that the List is a test case set.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310213068.7A CN116225942B (en) | 2023-03-08 | 2023-03-08 | Game engine development test system based on operation analysis |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310213068.7A CN116225942B (en) | 2023-03-08 | 2023-03-08 | Game engine development test system based on operation analysis |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116225942A true CN116225942A (en) | 2023-06-06 |
| CN116225942B CN116225942B (en) | 2023-11-10 |
Family
ID=86580364
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310213068.7A Active CN116225942B (en) | 2023-03-08 | 2023-03-08 | Game engine development test system based on operation analysis |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116225942B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118409975A (en) * | 2024-07-02 | 2024-07-30 | 杭州星河传世网络科技有限公司 | Game engine development test method and system |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109701273A (en) * | 2019-01-16 | 2019-05-03 | 腾讯科技（北京）有限公司 | Processing method, device, electronic equipment and the readable storage medium storing program for executing of game data |
| CN110457218A (en) * | 2019-08-07 | 2019-11-15 | Oppo广东移动通信有限公司 | Game engine test method, device, storage medium and electronic equipment |
| CN112033413A (en) * | 2020-09-07 | 2020-12-04 | 北京信息科技大学 | Improved A-algorithm combined with environmental information |
| CN112147998A (en) * | 2020-08-24 | 2020-12-29 | 同济大学 | Mobile robot path planning method based on region growing method |
| US20220028161A1 (en) * | 2020-07-24 | 2022-01-27 | Cesium GS, Inc. | Systems and methods for traversing implied subdivision hierarchical level of detail content |
-
2023
- 2023-03-08 CN CN202310213068.7A patent/CN116225942B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109701273A (en) * | 2019-01-16 | 2019-05-03 | 腾讯科技（北京）有限公司 | Processing method, device, electronic equipment and the readable storage medium storing program for executing of game data |
| CN110457218A (en) * | 2019-08-07 | 2019-11-15 | Oppo广东移动通信有限公司 | Game engine test method, device, storage medium and electronic equipment |
| US20220028161A1 (en) * | 2020-07-24 | 2022-01-27 | Cesium GS, Inc. | Systems and methods for traversing implied subdivision hierarchical level of detail content |
| CN112147998A (en) * | 2020-08-24 | 2020-12-29 | 同济大学 | Mobile robot path planning method based on region growing method |
| CN112033413A (en) * | 2020-09-07 | 2020-12-04 | 北京信息科技大学 | Improved A-algorithm combined with environmental information |
Non-Patent Citations (7)
| Title |
|---|
| KUO-LAN SU ET AL.: "A* search algorithm applied to a Chinese chess game", 《ARTIF LIFE ROBOTICS》, vol. 16 * |
| WEIXIN_34101229: "Mutation Testing(变异测试)", Retrieved from the Internet <URL:http://www.cnblogs.com/TongWee/p/4505289.html> * |
| 一棵橙子树: "bresenham算法模拟游戏中的追踪路线", Retrieved from the Internet <URL:https://mbd.baidu.com/ma/s.OK5y2knA> * |
| 周振华: "游戏场景中分层寻路算法及地图复杂性度量研究", 《中国优秀硕士学位论文全文数据库 信息科技辑》, no. 10 * |
| 林都: "复杂环境下基于遗传算法的路径规划", 《中国优秀硕士学位论文全文数据库信息科技辑》, no. 01 * |
| 邱雷: "游戏智能路径搜索算法研究及其系统开发", 《中国优秀硕士学位论文全文数据库信息科技辑》, no. 02 * |
| 钟瑛等: "融合A*和Bresenham的游戏路径规划算法设计与实现", 《电子技术与软件工程》, no. 09 * |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118409975A (en) * | 2024-07-02 | 2024-07-30 | 杭州星河传世网络科技有限公司 | Game engine development test method and system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116225942B (en) | 2023-11-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US5247651A (en) | Interactive computer program specification and simulation system | |
| Mauw et al. | A process specification formalism | |
| Bozga et al. | IF: An intermediate representation for SDL and its applications | |
| US7370296B2 (en) | Modeling language and method for address translation design mechanisms in test generation | |
| Martens | Ceptre: A language for modeling generative interactive systems | |
| US10489274B2 (en) | Using emulation to disassociate verification from stimulus in functional test | |
| Arcaini et al. | AsmetaSMV: a way to link high-level ASM models to low-level NuSMV specifications | |
| CN116225942B (en) | Game engine development test system based on operation analysis | |
| Perez et al. | Testing and debugging functional reactive programming | |
| Weil et al. | Efficient compilation of Esterel for real-time embedded systems | |
| Steffen et al. | Property-driven benchmark generation | |
| Hague | Saturation of concurrent collapsible pushdown systems | |
| Perez et al. | Runtime verification and validation of functional reactive systems | |
| Gregersen et al. | Almost-Sure Termination by Guarded Refinement | |
| EP0598476A2 (en) | Compilation mechanism for a simulation model | |
| Cyre | Executing conceptual graphs | |
| Al Dallal et al. | System testing for object-oriented frameworks using hook technology | |
| Ioannidis et al. | Structural temporal logic for mechanized program verification | |
| Castellani et al. | Exploring the Coordination Space with LO | |
| Jonge | The SpinJ model checker: a fast, extensible, object-oriented model checker | |
| Geilen | Non-exhaustive model-checking in component based systems | |
| Lewis | Producing network applications using object-oriented petri nets | |
| Normoyle et al. | The Curation Tree: A Lightweight Behavior Tree Framework for Implementing Puzzle and Narrative Games | |
| Reichel | Metamorphic testing of version control systems | |
| Hallin | SMT-Based Reasoning and Planning in TAL |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |