KR101975404B1 - Apparatus and method for generating procedural content - Google Patents

Abstract

The present invention relates to a device and a method for generating procedural content. The procedural content generating method comprises: a step of converting input data into a code by referring to a codebook; a step of extracting a pattern of the converted code by referring to the codebook; a step of adding the extracted pattern to the codebook and calculating entropy of content to be generated using the extracted pattern; and a step of repeating the entropy calculation by applying the extracted pattern to minimize the entropy until the entropy becomes 0. The present invention can minimize the use of memory resources until new content is created. The present invention automatically generates new content in real time, so the present invention can continue to deliver new content to users at a minimal cost.

Description

Procedural content generation device and method {APPARATUS AND METHOD FOR GENERATING PROCEDURAL CONTENT}

The present invention relates to a procedural content generating device and method for generating data with an algorithm.

In developing content for games, creating content is very important. If there is not a lot of content in the game, the player will consume the same content repeatedly and get tired of the game. However, creating content for game developers is time-consuming and expensive. As the content of the game grows, we can't handle everything by hand, and we need to create high-quality content with a minimum of manual effort.

Due to these needs, one of the proposed methods is a procedural content generation method. Procedural content generation refers to a method of automatically generating content by an algorithm during program execution, instead of generating predesigned content. Examples of procedurally generated game contents include terrain maps, texture images, audio, stream text files, quests, and items. If the computer processes the work of creating the content procedurally without designer intervention, the content can be produced cheaper and faster.

In particular, the dynamic procedural content creation method does not require allocating memory resources until the content is created, thus reducing the consumption of memory, reducing the cost of manually creating the game, and creating new content in real time. There is a need to develop an optimal procedural content generation method that can be generated.

United States Patent Application Publication US2014 / 0357365 (published Dec. 4, 2014), title of invention: ELECTRONIC GAME PERSONALIZATION

FDG '17 Proceedings of the 12th International Conference on the Foundation of Digital Games, Article No. `` Wave Function Collapse is Constraint Solving in the Wild '' by Isaac Karth, Adam M. Smith, 68.

An object of the present invention is to provide an apparatus and method for generating procedural content using bit entropy.

In order to achieve the above object, a method of generating procedural content according to an embodiment of the present invention comprises the steps of converting input data into a code with reference to a codebook, extracting a pattern with reference to the codebook, Adding the extracted pattern to the codebook, calculating an entropy of the content to be generated using the extracted pattern, and minimizing the entropy until the entropy becomes '0'. Repeating the entropy calculation by applying.

In addition, the method of generating a procedural content may further include generating the codebook by encoding specific data into a specific code according to a preset rule before converting the codebook into a code by referring to the codebook.

Computing the entropy of the data to be extended using the extracted pattern, setting the code indexing corresponding to the extracted pattern, calculate the entropy of the code corresponding to the generated content, the number of the extracted pattern The code indexing corresponding to the extracted pattern may be set to the number of bits corresponding to.

The method of generating procedural content may further include decoding the determined code indexing and generating the content of the data to be expanded after repeating the entropy calculation.

Here, the input data may be composed of at least one type of audio, image, text, or mixed data.

The extracted pattern may be in the form of an N * M matrix.

According to another embodiment of the present invention, there is provided a computer-readable recording medium having recorded thereon a program for executing a procedural content generating method according to the above method.

Further, according to another embodiment of the present invention, the apparatus for generating procedural content includes a memory in which an application related to procedural content generation is stored, and a processor for executing procedural content to generate procedural content. The processor executes the application to convert input data into codes by referring to a codebook, extracts the converted code by referring to the codebook, adds the extracted pattern to the codebook, and extracts the extracted code. The entropy of the content to be generated is calculated using the extracted pattern, and the entropy calculation may be repeated by applying the extracted pattern in such a way as to minimize the entropy until the entropy becomes '0'.

According to the present invention, the use of memory resources can be minimized until new content is generated, and new content can be automatically generated in real time, thereby providing new content to the user at a minimum cost.

1 is a flowchart of a procedural content generation method according to an embodiment of the present invention.
2A to 2B illustrate a first embodiment of converting code into a procedural content generating method according to an embodiment of the present invention.
3A to 3B illustrate a second embodiment of converting code into a procedural content generating method according to an embodiment of the present invention.
4 is an exemplary diagram of converting data of FIG. 2A into a codebook.
5A to 5B are diagrams for describing a method of analyzing a pattern in a procedural content generation method according to an embodiment of the present invention.
6 to 7 are diagrams for describing a method of determining a pattern in a procedural content generation method according to an embodiment of the present invention.
8A to 8D are diagrams illustrating a pattern form of each code determined by the method of FIG. 7.
9 is a diagram illustrating binarization of each code determined by the method of FIG. 7.
FIG. 10 is a diagram illustrating codes and entropy that can be arranged in up, down, left, right, and diagonal directions with respect to each code determined by the method of FIG. 7.
11A to 11Q are diagrams for describing a method of generating content of a 4 * 4 matrix using a procedural content generation method according to an embodiment of the present invention.

Hereinafter, an apparatus and a method for generating procedural content according to embodiments of the present invention will be described with reference to the accompanying drawings.

In the following description, in order to clarify the understanding of the present invention, description of well-known technology for the features of the present invention will be omitted. The embodiments are detailed description to assist in understanding the present invention, and do not limit the scope of the present invention. Therefore, equivalents that perform the same function as the present invention also fall within the scope of the present invention.

Hereinafter, specific embodiments will be described with reference to the accompanying drawings.

1 is a flowchart of a procedural content generation method according to an embodiment of the present invention.

Referring to FIG. 1, the procedural content generation method according to an embodiment of the present invention converts input data into codes, extracts a pattern, calculates entropy until the entropy becomes' 0 ', and the entropy is' If it is not 0 ', the content may be generated by repeatedly applying the extracted pattern.

In detail, the procedural content generating device may convert the input data into a code by referring to the codebook (S110). The input data may be composed of at least one type of audio, image, text, or mixed data.

The codebook is a coding work guide in which specific data is encoded into a specific code according to a predetermined rule, and is one of important guides in a code management and information processing system. The codebook should contain six items: Code table showing the relation between the data to be assigned and the corresponding code, operation method and example and explanation of the code table, processing of the data to be assigned which is difficult to cope with the code, detailed instruction example of the encoding operation, and encoding operation The codebook may contain code management rules that set the conditional tables and procedures for changing the code in order to facilitate this.

Next, the pattern of the converted code may be extracted with reference to the codebook (S120). Here, the pattern may be extracted in the form of an N * M matrix. For example, it can be extracted in the form of a 2 * 2 matrix, a 3 * 3 matrix. The extracted pattern and the central axis in each case may be stored in advance in the codebook. In this case, when the basic data is sufficient data to extract the pattern, the pattern may be extracted at a predetermined size (N * M). However, if the size of the basic data is not sufficient, the pattern may be extracted after generating the extended basic data using the rotation rule of the basic data. A method of extracting a pattern after generating extended basic data will be described in detail with reference to FIG. 6.

Next, the extracted pattern may be added to the codebook, and the entropy of the content to be generated may be calculated using the extracted pattern (S130). In detail, the process of calculating the entropy of the content to be generated using the extracted pattern may set the code indexing corresponding to the extracted pattern and calculate the entropy of the code corresponding to the content to be generated using the code indexing. . In this case, code indexing corresponding to the extracted pattern may be set to the number of bits corresponding to the number of extracted patterns. A detailed method of setting code indexing will be described with reference to FIG. 9.

It is determined whether all entropy of the generated content is '0' (S140). If the entropy is not '0', the calculation is repeated until the entropy becomes '0' by applying the extracted pattern. That is, when generating content of an N * M matrix, when the entropy of all coordinates of the matrix is equal to '1', the surrounding entropy is first calculated based on arbitrary coordinates, for example, (2, 3) coordinates. . If the total entropy is not '0', entropy is calculated by selecting the coordinate with the lowest entropy as the next center coordinate. For example, if entropy is computed with respect to the surrounding coordinates with the coordinate (2, 3) as the central axis, and the coordinate with the lowest peripheral entropy is (4, 2), entropy is returned with the (4, 2) as the central axis. Calculate The above process may be repeated while changing the center coordinates until the entropy becomes '0'. As described above, the procedural content generating apparatus may calculate entropy by changing coordinates in a direction in which entropy is minimized, and when the total entropy becomes '0', stops calculating and generates content with the determined code (S160).

The procedural content generation device may generate content to be generated by decoding the determined code indexing.

2A and 2B illustrate a first embodiment of converting code into a procedural content generating method according to an embodiment of the present invention, and FIGS. 3A through 3B illustrate a method of generating procedural content according to an embodiment of the present invention. A second embodiment of converting to code, and FIG. 4 is an exemplary diagram of converting data of FIG.

As described above, in the codebook, a 'code table indicating a relationship between granting data and a corresponding code' is stored. This code table can be preset by the user.

According to the first embodiment, the gray scale '160' of the image may be coded a, '23' to code b, '1' to code c, and '0' to code d, respectively. According to the above encoding method, an image of 3 * 3 pixels may be stored as a codebook as shown in FIG. 4.

According to the second embodiment, 'I'm' may be coded 'a', code 'b', space 'b', code c and 'boy' code d, respectively. By the above encoding method, the input string can be encoded as shown in [Table 1] below.

a b c b d

5A to 5B are diagrams for describing a method of analyzing a pattern in a procedural content generation method according to an embodiment of the present invention.

The codebook may be generated in various forms according to whether the type of content is an image, a string, audio, or the like, and the example of the image and the string has been described above.

The pattern analysis method in the case where the basic pattern stored in the codebook is two-dimensional (2 * 2 matrix) and three-dimensional (3 * 3 matrix) may be stored. For example, in the case of 2D, the pattern may be analyzed based on the central axis at the lower right, and in the case of 3D, the pattern may be analyzed based on the central axis. The central axis is hatched. That is, in the case of a three-dimensional pattern, a code table that matches a code arranged on a central axis may be found to predict (determine) codes in up, down, left, right, and diagonal directions, respectively.

6 to 7 are views for explaining a method of determining a pattern in the procedural content generation method according to an embodiment of the present invention, Figures 8a to 8d is a pattern form of each code determined by the method of FIG. Figure is a diagram.

6 is an embodiment in which a pattern is extracted by extending a basic codebook to extract a pattern of a 3 * 3 matrix for generating procedural content according to an embodiment of the present invention.

Referring to FIG. 6, the pattern of 3 * 3 matrix should be extracted. When the basic codebook is a 3 * 3 matrix that is not hatched, the pattern around the 3 * 3 matrix may be randomly determined by reflecting the rotation rule. Can be. That is, since the rotation rule of the first row of the center 3 * 3 matrix is a-b-d, 'a' can be extended to the right of d and 'd' to the left of a. Similarly, since the rotation rule of the first column of the center 3 * 3 matrix is a-c-b, 'a' can be extended below b and 'b' above a. In this way, the code can be extended to 4 * 4 matrices by surrounding code.

FIG. 7 is a method of extracting a 3 * 3 pattern from the extended codebook of FIG. 6. The 3 * 3 pattern may be extracted while moving from the left of the 4 * 4 matrix to the left and the bottom by '1'.

The pattern extracted in this way is a total of nine patterns, it is possible to store the extracted pattern in the codebook.

Referring to FIGS. 8A to 8D, it can be seen that patterns having a central axis as codes a, b, c, and d are divided into three, two, two, and two, respectively.

The pattern extraction method and the shape of the pattern is only one example and may be modified in various forms.

FIG. 9 is a diagram illustrating binarization of each code determined by the method of FIG. 7, and FIG. 10 is a code that can be arranged in the up, down, left, right, and diagonal directions with respect to each code determined by the method of FIG. 7. And entropy.

Referring to FIG. 9, codes a, b, c, and d of FIG. 7 may be binarized and displayed. Specifically, code a may be defined as '1000', code b as '0100', code c as '0010', and code d as '0001'. In this case, each code may be binarized by the number of bits corresponding to the number of all codes a, b, c, and d. This binarization method is only an embodiment, and code indexing may be set in various ways.

Referring to FIG. 10, the codes and entropy that can be arranged in the up, down, left, right, and diagonal directions when each code is disposed at the center are shown.

For example, when the code a is disposed on the central axis of the 3 * 3 pattern, after confirming the pattern related to the code a with reference to FIG. 8A, the code that can be disposed on the upper side of the 'b' or 'd' Can be determined. In this case, since either 'b' or 'd' should be disposed above a, entropy decreases from 1 to 0.5, and code indexing becomes '0101'. In the same manner, a pattern may be applied to the lower, left, right, and diagonal directions of the code a to obtain a result as shown in FIG. 10.

In the same manner, the extracted patterns of FIGS. 8A to 8D may be used to determine codes and entropies that may be disposed around each of the cases where codes b, c, and d are located on the central axis.

11A to 11Q are diagrams for describing a method of generating content of a 4 * 4 matrix using a procedural content generation method according to an embodiment of the present invention.

Referring to FIGS. 11A to 11Q, any code consisting of four codes a, b, c, and d is described with reference to the codebook generated in FIGS. 8A to 8D by a procedural content generation method according to an embodiment of the present invention. You can create the contents of a 4 * 4 matrix.

Referring to FIG. 11A, the content of any 4 * 4 matrix may be located in any code a, b, c, d with an entropy of all coordinates '1' in an initial state. Hereinafter, each coordinate is represented by the form (x, y), x represents the number of columns, y represents the number of rows, and the coordinate of the lower left corner is set to (0, 0).

Referring to FIG. 11B, after a code of (4, 2) coordinates among 16 coordinates is arbitrarily determined as 'b', a code and entropy around the (4, 2) coordinates may be calculated. At this time, since the (4, 2) coordinate is determined by the code b, the entropy becomes '0'.

Referring to FIG. 11C, the neighboring code of code b may be determined with reference to FIG. 10. That is, referring to the codebook related to the probability of existence in code b of FIG. 10, 'a' or 'c' may be disposed above b, entropy is '0.5', and 'a' or 'd' below. It can be seen that 'can be arranged, the entropy is' 0.5', 'a' or 'c' can be placed on the right side, and the entropy is' 0.5 '. In addition, 'a', 'b', 'c' and 'd' may be on the left diagonal upper side and the lower side, respectively, and the entropy becomes '0.5'.

 Referring to FIG. 11D, the code and entropy of the peripheral coordinates are recalculated about (4, 3), which is one of coordinates having an entropy '0.5' adjacent to the (4, 2) coordinate. Specifically, (4, 3) may be 'a' or 'c', so that if the 'a' is placed code and entropy that can be placed around the 'c' can be placed around You can determine the entropy around (4, 3) by adding the code and entropy.

Referring to FIG. 11E, the code and entropy of the peripheral coordinates are recalculated based on the (3, 3) coordinates. (3, 3) can be either 'a' or 'b', so that code that can be placed around if 'a' is placed and code that can be placed around if entropy and 'b' are placed Entropy can be added to determine entropy around (3, 3).

Referring to FIG. 11F, the code and entropy of the peripheral coordinates are recalculated based on the (3, 2) coordinates. (3, 2) can be either 'a' or 'c', so that code that can be placed around if 'a' is placed and code that can be placed around if entropy and 'c' are placed Entropy can be added to determine entropy around (3, 2).

Referring to FIG. 11G, the code and entropy of the peripheral coordinates are recalculated around the (3, 1) coordinates. (3, 1) can be 'c' or 'd', so code that can be placed around if 'c' is placed and code that can be placed around if entropy and 'd' are placed Entropy can be added to determine entropy around (3, 1).

11H-11Q, in the same manner, it is possible to calculate the code and entropy that can be placed around other coordinates. When entropy calculation is completed with reference to a pattern for all coordinates and it is no longer possible to lower entropy, one may arbitrarily select one of two codes scheduled for one coordinate and repeat the process of FIGS. 11A to 11Q. By repeating this process, when the total entropy becomes '0', the determined code can be decoded and generated as content.

Although not shown, the apparatus for generating procedural content according to another embodiment of the present invention may include a memory and a processor.

In detail, the memory may store an application related to procedural content generation, and the processor may execute an application related to procedural content generation to generate procedural content. In addition, the processor executes an application to convert the input data into code by referring to the codebook, extracts the pattern by referring to the codebook, adds the extracted pattern to the codebook, and generates the extracted pattern using the extracted pattern. The entropy of the content can be calculated. The processor may generate content by repeating the entropy calculation by applying the extracted pattern in such a way as to minimize entropy until the entropy becomes '0'.

In the above-described procedural content generation method according to an embodiment of the present invention, an application basically installed in the procedural content generating apparatus (which may include a program included in a platform or an operating system, etc., which is basically installed in a terminal). It may be executed by the user, or may be executed by an application (program) directly installed on the terminal by an application providing server, such as an application store server, an application, or a web server associated with the corresponding service.

In this sense, the above-described procedural content generating apparatus according to an embodiment of the present invention is implemented as an application (program) basically installed in a terminal or directly installed by a user, and recorded in a computer-readable recording medium such as a terminal. Can be. Such a program is recorded on a recording medium readable by a computer and executed by a computer so that the above functions can be executed.

As described above, a program for executing a procedural content generation method according to an embodiment of the present invention may be coded in a computer language such as C, C ++, JAVA, or machine language that can be read by a computer processor (CPU). ) May be included.

Such code may further include memory reference related code for additional information or media required for the computer's processor to execute the functions at which location (address, address) of the computer's internal or external memory should be referenced.

Functional programs for implementing the present invention, and related code and code segments thereof, may be easily used by programmers in the technical field to which the present invention belongs, in consideration of a system environment of a computer that executes a program by reading a recording medium. Can be deduced or changed.

Recordable media that can be read by a computer recording the above program include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical media storage device, and the like.

In the above description, all elements constituting the embodiments of the present invention are described as being combined or operating in combination, but the present invention is not necessarily limited to the embodiments. In other words, within the scope of the present invention, all of the components can be selectively combined to operate at least one. In addition, although all of the components may be implemented in one independent hardware, each or all of the components may be selectively combined to perform some or all functions combined in one or a plurality of hardware. It may be implemented as a computer program having a. Codes and code segments constituting the computer program may be easily inferred by those skilled in the art. Such a computer program may be stored in a computer readable storage medium and read and executed by a computer, thereby implementing embodiments of the present invention. The storage medium of the computer program may include a magnetic recording medium, an optical recording medium, and the like.

The above description is merely illustrative of the technical idea of the present invention, and those skilled in the art to which the present invention pertains may make various modifications and changes without departing from the essential characteristics of the present invention. Therefore, the embodiments disclosed in the present invention are not intended to limit the technical idea of the present invention but to describe the present invention, and the scope of the technical idea of the present invention is not limited by these embodiments. The protection scope of the present invention should be interpreted by the following claims, and all technical ideas within the equivalent scope should be interpreted as being included in the scope of the present invention.

S110: Convert Input Data to Code S120: Extract Pattern
S130: Entropy calculation S140: Entropy '0'?
S150: Apply Pattern S160: Create Content

Claims (8)

In the method for generating content by the procedural content generating device,
Converting the input data into a code by referring to the codebook;
Extracting a pattern of the converted code by referring to the codebook;
Adding the extracted pattern to the codebook and calculating an entropy of the content to be generated using the extracted pattern; And
Repeating the entropy calculation by applying the extracted pattern in such a way as to minimize the entropy until the entropy becomes '0';
Procedural content generation method comprising a.
The method of claim 1,
Before the step of converting to code by referring to the codebook,
And encoding the specific data into a specific code according to a preset rule to generate the codebook.
The method of claim 1,
Calculating the entropy of the content to be generated using the extracted pattern,
Set the code indexing corresponding to the extracted pattern, calculate the entropy of the code corresponding to the generated content,
And setting the code indexing corresponding to the extracted pattern to the number of bits corresponding to the number of the extracted patterns.
The method of claim 3,
After repeating the entropy calculation,
Decoding the set code indexing to generate the content;
Further comprising, procedural content generation method.
The method of claim 1,
And the input data comprises at least one type of audio, image, or text, or in the form of mixed data.
The method of claim 1,
And the extracted pattern is in the form of an N * M matrix.
A computer-readable recording medium having recorded thereon a program for executing the procedural content generating method according to any one of claims 1 to 6.
A memory in which an application related to procedural content generation is stored; And
And a processor for generating procedural content by executing an application related to the procedural content generation.
The processor,
Execute the application to convert the input data into codes by referring to the codebook,
Extracting the pattern from the converted code by referring to the codebook,
Add the extracted pattern to the codebook, calculate entropy of the content to be generated using the extracted pattern,
And applying the extracted pattern in such a manner as to minimize the entropy until the entropy becomes '0' and repeating the entropy calculation.

Images