Computer program product, information processing system, information processing device, and information processing method

Abstract

The invention provides a computer program product, an information processing system, an information processing apparatus, and an information processing method. The information processing system generates a grid of the main object in the virtual space on the basis of the main body element data for each main body element. In an information processing system, when an elimination event has occurred, main body element data of a voxel to be eliminated in which the elimination event has occurred is updated such that at least a portion corresponding to the voxel to be eliminated is eliminated. In an information processing system, when an elimination event has occurred, it is determined whether or not a fragment generation condition is satisfied on the basis of property data relating to a voxel to be eliminated. In the information processing system, when it is determined that the debris generation condition is satisfied, sub-voxel data, which is voxel data of a sub-object, is generated, and a mesh of the sub-object is generated in the virtual space on the basis of the sub-voxel data.

Description

Technical Field

[0001] The present invention relates to a computer program product, an information processing system, an information processing apparatus, and an information processing method for generating an object in a virtual space using voxel data. Background Art

[0002] Conventionally, the following processing has been performed: managing an object using voxel data and generating a mesh of the object in a virtual space based on the voxel data (for example, "Marching cubes: A high resolution 3D surface construction algorithm", Computer Graphics, Volume 21, Number 4, WE Lorensen, HE Cline, 1987).

[0003] Conventionally, in the case where an object based on voxel data is damaged in a virtual space or the like, there has been a problem regarding how to generate an object corresponding to the damaged part.

[0004] Therefore, an object of the present invention is to provide a computer program product, an information processing system, an information processing apparatus, and an information processing method capable of generating an object representing a damaged part or the like of an object. Summary of the Invention

[0005] In order to solve the above problems, the present invention adopts the following structures (1) to (19). (1)

[0007] An example of the present invention is a computer program product including an information processing program executed in a computer of an information processing apparatus. The information processing program causes the computer to function as a main object generation unit, a main voxel update unit, a fragment determination unit, a sub-object generation unit, and an image output unit. The main object generation unit generates a mesh of a main object in a virtual space based on main voxel data of each main voxel defined in a main voxel space which is a voxel space set in the virtual space. When an elimination event occurs for at least a part of a plurality of main voxels in the main voxel space, the main voxel update unit updates the main voxel data of the main voxel where the elimination event has occurred, that is, the elimination target voxel, so that at least a part of the main object corresponding to the elimination target voxel is eliminated. When an elimination event occurs, the fragment determination unit determines whether a fragment generation condition is satisfied based on property data related to the elimination target voxel among property data representing the property of the main object for each main voxel. When it is determined that the fragment generation condition is satisfied, the sub-object generation unit generates voxel data of a sub-object, that is, sub-voxel data, and generates a mesh of the sub-object in the virtual space based on the sub-voxel data, where the sub-voxel data is voxel data of each sub-voxel defined in a sub-voxel space which is different from the main voxel space and is set in the virtual space. The image output unit outputs an image of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device.

[0008] According to the structure of (1) above, it is possible to generate an object representing a damaged part of the main object based on sub-voxel data related to a sub-voxel space different from the main voxel space. (2)

[0010] Alternatively, the information processing program may cause the computer to further function as an appearance setting unit. The appearance setting unit sets the color and / or pattern of the mesh of the main object based on appearance data defining the color and / or pattern of the main object for each main voxel.

[0011] According to the structure of (2) above, by using the appearance data, it is possible to set the color and / or pattern of the main object for each main voxel. (3)

[0013] Alternatively, the appearance data may be data representing a texture. Alternatively, the appearance setting unit applies the texture represented by the appearance data related to a certain main voxel to the mesh of the main object generated based on the voxel data of the certain main voxel.

[0014] According to the structure of (3) above, by using the appearance data, it is possible to set the texture applied to the main object for each main voxel. (4)

[0016] Alternatively, the sub-object generation unit may determine the appearance data set for the sub-voxels related to the sub-object based on the appearance data set for the eliminated part in the main object.

[0017] According to the structure of (4) above, it is possible to generate a sub-object having an appearance corresponding to the appearance of the eliminated part of the main object. (5)

[0019] Alternatively, the sub-object generation unit may determine the property data set for the sub-voxels related to the sub-object based on the property data set for the eliminated part in the main object.

[0020] According to the structure of (5) above, it is possible to generate a sub-object having a property corresponding to the property of the eliminated part of the main object. (6)

[0022] Alternatively, the information processing program may cause the computer to also function as a number determination unit. The number determination unit determines the number of sub-objects to be generated based on the type of the elimination event that has occurred. Alternatively, in the case where it is determined to generate a plurality of sub-objects, the sub-object generation unit generates sub-voxel data related to each sub-object in each of the plurality of mutually independent sub-voxel spaces, and generates a mesh of the sub-object in the virtual space based on each of the sub-voxel data.

[0023] According to the structure of (6) above, it is possible to specify in detail the number of sub-objects to be generated for each type of elimination event. (7)

[0025] Alternatively, the fragment determination unit sets the conditions used as the fragment generation conditions and / or determines whether the fragment generation conditions are satisfied based on the type of the elimination event that has occurred.

[0026] According to the structure of (7) above, it is possible to cause the conditions for generating the sub-object and / or the generation result of the sub-object to change corresponding to the type of the elimination event. (8)

[0028] Alternatively, in the case where an elimination event has occurred due to an impact application event in which an impact is applied to the main object, the fragment determination unit discriminates the type of the elimination event based on the type of the impact application event.

[0029] According to the structure of (8) above, it is possible to cause the conditions for generating the sub-object and / or the generation result of the sub-object to change corresponding to the type of the impact application event. (9)

[0031] Alternatively, in a case where a first impact application event occurs due to an action of causing a collision object held by a player object to collide with a main object, and in a case where a second impact application event occurs due to an action of causing the collision object to collide with the main object by moving the collision object toward the main object by the player object, the fragment determination unit determines that different types of elimination events have occurred.

[0032] According to the structure of (9) above, the generation result of the sub-object can be made different according to the action performed by the player object. (10)

[0034] Alternatively, in a case where an event of a sub-object colliding with a main object is performed as an impact application event, the fragment determination unit determines whether an elimination event has occurred.

[0035] According to the structure of (10) above, it is possible to further eliminate the main object using the sub-object obtained by eliminating the main object, and thus the strategy of the game related to the elimination of the main object can be improved. (11)

[0037] Alternatively, the property data represents the strength of the main object. Alternatively, the fragment determination unit determines whether the fragment generation condition is satisfied based on the strength corresponding to the type of the elimination event that has occurred and the strength represented by the property data set for the elimination object voxel for which the elimination event has occurred.

[0038] According to the structure of (11) above, the generation result of the sub-object can be made different according to the type of the elimination event and the property of the main object. (12)

[0040] Alternatively, the property data represents the strength of the main object. Alternatively, in a case where an impact application event of applying an impact to the main object is performed, the fragment determination unit determines whether an elimination event has occurred based on the strength of the impact application event set according to the type of the impact application event and the strength represented by the property data set for the main voxel to which the impact application event has been performed.

[0041] According to the structure of (12) above, whether an elimination event occurs can be made different according to the type of the impact application event and the property of the main object. (13)

[0043] Alternatively, the sub-object generation unit generates sub-voxel data in such a way as to form a sub-object having a size corresponding to the type of the elimination event that has occurred.

[0044] According to the structure of (13) above, the size of the sub-object can be set in detail for each type of the elimination event. (14)

[0046] Alternatively, when it is determined that the fragment generation condition is satisfied, the sub-object generation unit generates an elimination part object representing the eliminated part in the main object, and generates a sub-object by dividing the elimination part object into a plurality of parts.

[0047] According to the structure of the above (14), it is possible to generate a sub-object in accordance with the shape of the eliminated part of the main object. (15)

[0049] Alternatively, the sub-object generation unit generates sub-voxel data in such a way that an object within a range greater than the lower limit value and less than the upper limit value among the objects obtained by dividing the elimination part object into a plurality of parts becomes a sub-object.

[0050] According to the structure of the above (15), it is possible to reduce the possibility of generating an overly large or overly small sub-object. (16)

[0052] Alternatively, when the sub-object collides with the main object, the main object generation unit updates the main voxel data based on the sub-voxel data to add a part corresponding to the sub-object to the main object in the main voxel space.

[0053] According to the structure of the above (16), it is possible to integrate two objects with different voxel spaces (i.e., the main object and the sub-object) into one object defined by the main voxel data. (17)

[0055] Alternatively, the sub-object generation unit sets a sub-voxel space in which voxels having a length shorter than one side compared to the main voxel are defined as sub-voxels.

[0056] According to the structure of the above (17), it is possible to represent the shape of the sub-object based on the sub-voxel data in more detail than the main object based on the main voxel data. (18)

[0058] Alternatively, the sub-object generation unit independently sets the direction of the coordinate axes in the sub-voxel space with respect to the direction of the coordinate axes in the main voxel space.

[0059] According to the structure of the above (18), it is easy to arrange the sub-object in a free direction in the virtual space. (19)

[0061] Alternatively, the main object is a terrain object arranged in the virtual space.

[0062] According to the structure of (19) above, an object that can generate a part representing the destruction of a terrain object or the like can be generated.

[0063] In addition, another example of the present invention may be an information processing device (for example, a terminal device or a server) or an information processing system including all or part of the units in (1) to (19) above. Another example of the present invention may also be an information processing method (specifically, a game processing method) for causing an information processing system to execute the respective processes in (1) to (19) above.

[0064] According to the above computer program product, information processing system, information processing device, and information processing method, an object that can generate a part representing the destruction of an object or the like can be generated.

[0065] By referring to the accompanying drawings, the above and other objects, features, aspects, and effects will be further clarified from the following detailed description. Description of the Drawings

[0066] Figure 1 FIG. is a diagram showing an example of a game system.

[0067] Figure 2 FIG. is a block diagram showing an example of the internal structure of the main device.

[0068] Figure 3 FIG. is a block diagram showing an example of the internal structures of the main device, the left controller, and the right controller.

[0069] Figure 4 FIG. is a diagram showing an example of a terrain object as a voxel object.

[0070] Figure 5 FIG. shows Figure 4 an example of the situation before and after a part of the terrain object shown is deleted.

[0071] Figure 6 FIG. shows Figure 4 an example of the situation before and after a part of the terrain object shown is deleted.

[0072] Figure 7 FIG. is a diagram showing an example of the content of voxel data and the content of material information.

[0073] Figure 8 FIG. is a diagram showing an example of property information representing the properties of a material.

[0074] Figure 9 FIG. is a diagram showing an example of texture information representing the texture of a material.

[0075] Figure 10This is a diagram showing an example of a method for generating a grid.

[0076] Figure 11 This is a diagram showing an example of a game image including a terrain object.

[0077] Figure 12 This is a diagram showing an example of a situation where a player object punches a terrain object.

[0078] Figure 13 This is a diagram showing an example of a terrain object that has been partially destroyed as a result of a punching action by a player object.

[0079] Figure 14 This is a diagram showing an example of a terrain object and a debris object.

[0080] Figure 15 This is a diagram showing an example of debris generation information.

[0081] Figure 16 This is a diagram showing an example of a method for generating a debris object.

[0082] Figure 17 This is a diagram showing an example of a situation where a player object throws a debris object towards a terrain object.

[0083] Figure 18 This is a diagram showing an example of a situation where a terrain object is added as a result of contact between a debris object and a terrain object.

[0084] Figure 19 This is a diagram showing an example of various data used in information processing in a game system.

[0085] Figure 20 This is a flowchart showing an example of the flow of game processing executed by a game system.

[0086] Figure 21 This is showing Figure 20 A sub - flowchart showing an example of the detailed flow of the elimination process of step S6 shown.

[0087] Figure 22 This is showing Figure 20 A sub - flowchart showing an example of the detailed flow of the addition process of step S8 shown. Detailed implementation

[0088] [1. Structure of the game system]

[0089] Next, a game system according to an example of this embodiment will be described. Figure 1This is a diagram showing an example of a game system. An example of the game system 1 in the present embodiment includes a main unit (information processing device, which functions as the main body of the game device in the present embodiment) 2, a left controller 3, and a right controller 4. The main unit 2 is a device that executes various processes (for example, game processes) in the game system 1. The left controller 3 and the right controller 4 are devices having operation units for user input.

[0090] The left controller 3 and the right controller 4 can be respectively attached to and detached from the main unit 2. That is, the game system 1 can be used as a device in which the left controller 3 and the right controller 4 are respectively attached to the main unit 2 to be integrated. In addition, the game system 1 can also use the main unit 2, the left controller 3, and the right controller 4 independently. Further, hereinafter, the left controller 3 and the right controller 4 may be collectively referred to as "controllers".

[0091] Figure 2 This is a block diagram showing an example of the internal structure of the main unit 2. In addition to having the Figure 1 shown structure, the main unit 2 also has Figure 2 each of the components 17, 21, 23, 81 to 85, and 91 shown. Some of these components 17, 21, 23, 81 to 85, and 91 may also be mounted as electronic components on a circuit board and housed in a housing 11.

[0092] The main unit 2 is provided with a display 12. The display 12 is used to display the images generated by the main unit 2. In the present embodiment, it is assumed that the display 12 is a liquid crystal display device (LCD). However, the display 12 can be any type of display device.

[0093] In addition, the main unit 2 is provided with a left terminal 17 as a terminal for the main unit 2 to perform wired communication with the left controller 3, and a right terminal 21 for the main unit 2 to perform wired communication with the right controller 4.

[0094] The main unit 2 is provided with a processor 81. The processor 81 is an information processing unit that executes various information processes executed in the main unit 2. For example, it can be composed of only a CPU (Central Processing Unit), or can be composed of an SoC (System-on-a-chip) including multiple functions such as CPU functions and GPU (Graphics Processing Unit) functions. The processor 81 executes various information processes by executing information processing programs (for example, game programs) stored in a storage unit (specifically, an internal storage medium such as a flash memory 84, or an external storage medium installed in a slot 23, etc.).

[0095] As an example of an internal storage medium built into itself, the main unit 2 includes a flash memory 84 and a DRAM (Dynamic Random Access Memory) 85. The flash memory 84 and the DRAM 85 are connected to the processor 81. The flash memory 84 is a memory mainly used to store various data (which may also be programs) stored in the main unit 2. The DRAM 85 is a memory used to temporarily store various data used in information processing.

[0096] The main unit 2 includes a slot 23. The slot 23 is provided on the upper side surface of the housing 11. The slot 23 has a shape capable of mounting a storage medium of a specified type. The storage medium of the specified type is, for example, a storage medium (e.g., a dedicated memory card) dedicated to the game system 1 and information processing devices of the same type as it. The storage medium of the specified type is used, for example, to store data (e.g., save data of applications, etc.) used in the main unit 2 and / or programs (e.g., application programs, etc.) executed in the main unit 2. In addition, the main unit 2 includes a power button 28.

[0097] The main unit 2 includes a slot interface (hereinafter simply referred to as "I / F"). The slot I / F 91 is connected to the processor 81. The slot I / F 91 is connected to the slot 23 and reads and writes data to and from a storage medium of a specified type (e.g., a dedicated memory card) mounted in the slot 23 according to an instruction from the processor 81.

[0098] The processor 81 appropriately reads or writes data among the flash memory 84, the DRAM 85, and the above-mentioned respective storage media to execute the above-mentioned information processing.

[0099] The main unit 2 includes a network communication unit 82. The network communication unit 82 is connected to the processor 81. The network communication unit 82 communicates with an external device via a network (specifically, wireless communication). In the present embodiment, the network communication unit 82 connects to a wireless LAN and communicates with an external device by a method conforming to the Wi-Fi standard as a first communication method. In addition, the network communication unit 82 performs wireless communication with other main units 2 of the same type by a specified communication method (e.g., communication based on a custom protocol, infrared communication) as a second communication method. Furthermore, the wireless communication based on the above-mentioned second communication method can perform wireless communication with other main units 2 arranged within a closed local area network, realizing a function of so-called "local communication" capable of directly communicating and receiving data between multiple main units 2.

[0100] The main device 2 is provided with a controller communication unit 83. The controller communication unit 83 is connected to the processor 81. The controller communication unit 83 performs wireless communication with the left controller 3 and / or the right controller 4. The communication method between the main device 2 and the left controller 3 and the right controller 4 is arbitrary. In the present embodiment, the controller communication unit 83 performs communication conforming to the Bluetooth (registered trademark) standard between the left controller 3 and between the right controller 4.

[0101] The processor 81 is connected to the above-mentioned left terminal 17 and right terminal 21. When the processor 81 performs wired communication with the left controller 3, it transmits data to the left controller 3 via the left terminal 17 and receives operation data from the left controller 3 via the left terminal 17. In addition, when the processor 81 performs wired communication with the right controller 4, it transmits data to the right controller 4 via the right terminal 21 and receives operation data from the right controller 4 via the right terminal 21. Thus, in the present embodiment, the main device 2 can perform both wired communication and wireless communication with the left controller 3 and the right controller 4 respectively.

[0102] In addition, the display 12 is connected to the processor 81. The processor 81 displays the image generated (for example, by executing the above-mentioned information processing) and / or the image acquired from the outside on the display 12.

[0103] Figure 3 It is a block diagram showing an example of the internal structures of the main device 2, the left controller 3, and the right controller 4. In addition, regarding the details of the internal structure related to the main device 2, they have been shown in Figure 2 and are thus omitted in Figure 3

[0104] The left controller 3 is provided with a terminal 42 for the left controller 3 to perform wired communication with the main device 2. In addition, the left controller 3 is provided with a communication control unit 101 for communicating with the main device 2. As Figure 3 shown, the communication control unit 101 is connected to each component including the terminal 42. In the present embodiment, the communication control unit 101 can communicate with the main device 2 by both wired communication via the terminal 42 and wireless communication without passing through the terminal 42. The communication control unit 101 controls the communication method of the left controller 3 with respect to the main device 2. That is, when the left controller 3 is installed on the main device 2, the communication control unit 101 communicates with the main device 2 via the terminal 42. In addition, when the left controller 3 is detached from the main device 2, wireless communication is performed between the communication control unit 101 and the main device 2 (specifically, the controller communication unit 83).

[0105] ​In addition, the left controller 3 includes a memory 102 such as a flash memory. The communication control unit 101 is constituted by, for example, a microcomputer (also referred to as a microprocessor), and executes various processes by executing the firmware stored in the memory 102.

[0106] The left controller 3 is provided with one or more buttons 103. In addition, the left controller 3 is provided with an analog joystick (referred to as a "joystick" in Figure 3 the description) 32. The buttons 103 and the analog joystick 32 repeatedly output information related to the operations performed on themselves to the communication control unit 101 at appropriate times.

[0107] The communication control unit 101 acquires information related to input (specifically, information related to operations) from each input unit (specifically, the buttons 103 and the analog joystick 32). The communication control unit 101 transmits operation data including the acquired information (or information obtained by subjecting the acquired information to prescribed processing) to the main body device 2. In addition, the operation data is repeatedly transmitted at a rate of once every prescribed time. In addition, the intervals at which information related to input is transmitted to the main body device 2 may be the same or different in each input unit.

[0108] By transmitting the above operation data to the main body device 2, the main body device 2 can recognize the input to the left controller 3. That is, the main body device 2 can determine the operations of moving the left controller 3 and the operations of the buttons 103 and the analog joystick 32 based on the operation data.

[0109] The left controller 3 is provided with a power supply unit 108. In the present embodiment, the power supply unit 108 includes a battery and a power control circuit. Although not shown, the power control circuit is connected to the battery and is also connected to each part of the left controller 3 (specifically, the parts that receive the power supply from the battery).

[0110] As Figure 3 shown, the right controller 4 is provided with a communication control unit 111 that communicates with the main body device 2. In addition, the right controller 4 is provided with a memory 112 connected to the communication control unit 111. The communication control unit 111 is connected to each component including the terminal 64. The communication control unit 111 and the memory 112 have the same functions as the communication control unit 101 and the memory 102 of the left controller 3. Therefore, the communication control unit 111 can communicate with the main body device 2 by both wired communication via the terminal 64 and wireless communication without passing through the terminal 64 (specifically, communication conforming to the Bluetooth (registered trademark) standard), and the right controller 4 controls the communication method with the main body device 2.

[0111] The right controller 4 has the same input parts as those of the left controller 3. Specifically, the right controller 4 has a button 113 and an analog joystick 52. These input parts have the same functions as those of the left controller 3 and operate in the same manner.

[0112] The right controller 4 has a power supply unit 118. The power supply unit 118 has the same function as the power supply unit 108 of the left controller 3 and operates in the same manner.

[0113] [2. Outline of Processing in the Game System]

[0114] Next, with reference to Figures 4 to 18 the outline of the processing executed in the game system 1 will be described. In the present embodiment, the game system 1 generates a game image in which terrain objects and characters (for example, player objects operated by a player) are arranged in a game space that is a three-dimensional virtual space, and causes the display device to display the game image. In addition, in the present embodiment, the display device for displaying the game image may be the above-mentioned display 12 or a display device different from the display 12 (for example, a fixed monitor connected to the game system 1).

[0115] [2-1. Voxel]

[0116] In the present embodiment, for several objects in the game space, their shapes are defined by voxel data. Here, a voxel refers to a cuboid (more specifically, a cube)-shaped region arranged in a grid pattern in the game space, and voxel data refers to data set for each voxel. Hereinafter, an object whose shape is defined by voxel data will be referred to as a "voxel object". In the present embodiment, the game system 1 stores voxel data for each of the multiple voxels set in the game space as data for generating voxel objects in the game space.

[0117] Figure 4 is a diagram showing an example of a terrain object as a voxel object. As Figure 4 shown, in the present embodiment, the shape of the terrain object representing terrain such as the ground is defined by voxel data (that is, it is a voxel object). Figure 4 Each cube shown represents a terrain object. In addition, in Figure 4 the boundaries of the voxels are shown by thin lines, and the parts that become the edges of the terrain object are shown by thick lines, but these lines are marked for the purpose of making the drawings easier to view. In reality, there is no need to display the lines representing the boundaries of the voxels, nor to thicken the edges of the terrain object.

[0118] In addition, Figure 4The terrain object shown is generated according to the following rule: "When the parameter (specifically, the density described later) included in the voxel data set for a voxel is greater than a specified value, a cube is arranged at the position of the voxel, and when it is equal to or less than the specified value, nothing is arranged at the position of the voxel." In Figure 4 a terrain object generated according to the above rule is shown for the purpose of exemplifying the relationship between voxels and voxel objects in an easy-to-understand manner. In the present embodiment, actually, for example, as the terrain object shown in Figure 11 , voxel objects are generated according to a rule that forms a shape more complex than the length of one side of a voxel. In addition, the rule for determining the shape of a voxel object based on voxel data is arbitrary. In other embodiments, the game system 1 can generate voxel objects such as those shown in Figure 4 or can generate voxel objects such as those shown in Figure 11 based on voxel data.

[0119] For a voxel object, its shape can be changed by changing the voxel data of each voxel. Figure 5 and Figure 6 are diagrams showing an example of the situation before and after a part of the terrain object shown in Figure 4 is eliminated. That is, when the slanted part in the terrain object shown in Figure 5 is eliminated, the terrain object changes to the shape shown in Figure 6 . At this time, the game system 1 can easily eliminate the terrain object by rewriting the voxel data of the voxels in the above slanted part to indicate that there is no terrain object. In addition, in the game system 1, when adding a terrain object, the voxel data of each voxel is also changed in the same way as when eliminating a terrain object, so that the shape of the terrain object can be easily changed.

[0120] In this way, the game system 1 can freely change the shape of a voxel object by rewriting voxel data. For example, there are cases where the terrain object in the game is damaged for some reason (for example, the player object strikes the terrain object) and as a result, the shape of the terrain object changes. In this case, the game system 1 can freely change the shape of the terrain object by changing the voxel data used in the generation of the terrain object without directly changing the data representing the external shape of the terrain object (that is, the mesh described later).

[0121] Figure 7This is an example of a diagram showing the content of voxel data and the content of material information. Here, in the present embodiment, the game space can be divided into a plurality of voxels arranged in a grid pattern. The game system 1 stores each voxel in the game space in association with voxel data. The voxel data represents the presence or absence of voxel objects in the voxel corresponding to the voxel data, etc.

[0122] As Figure 7 shown, the voxel data includes density data. The density data represents a density, which is an index used to define the shape of the voxel object in the voxel corresponding to the voxel data (specifically, the shape defined by the mesh described later). Details will be described later, but the position and shape of the surface of the voxel object (i.e., the mesh described later) are determined based on the above density. That is, in the present embodiment, the above density is used to create a mesh for defining the surface of the voxel object.

[0123] In the present embodiment, the density can take an integer value in the range from a lower limit value (e.g., 0) to an upper limit value (e.g., 255). In the present embodiment, the game system 1 determines the shape of the voxel object based on the density in the following manner: when the value of the density set for the voxel is high, the proportion of the volume occupied by the voxel object in the voxel tends to be large, and when the value of the density is low, this proportion tends to be small. In this way, the density is an index that affects the proportion of the volume occupied by the voxel object in the voxel. The density can also be said to be an index representing the degree of inclusion of an object in the region defined in each voxel. For example, when the density is 0, there is no voxel object in the voxel, when the density is 255, the entire voxel is a voxel object, and when the value is between 0 and 255, the voxel object can occupy a proportion corresponding to the value in the voxel. Moreover, the shape of the mesh, that is, the shape of the voxel object, can be determined based on the above density. However, the voxel object generated based on the above density does not need to have a volume that is strictly consistent with the proportion indicated by the density. For example, in the method of generating a voxel object such as Figure 8 this and the method of generating a voxel object such as Figure 15 this, sometimes even based on the same density, the volume of the voxel object is different.

[0124] In other embodiments, the density can also represent either the state where the voxel object occupies the entire region in the voxel or the state where the region in the voxel does not contain the voxel object. For example, the density data can be data that can only take 0 or 1.

[0125] As Figure 7As shown, the voxel data includes material data. The material data represents the material (in other words, the substance) of the voxel object generated based on the voxel data. Here, in the present embodiment, materials such as sand, rock, and soil are set in the voxel object. That is, in the present embodiment, multiple types of materials are prepared as the materials that can be set for the voxel object, and any one of the multiple types of materials is set for the voxel object.

[0126] As Figure 7 shown, in the present embodiment, the material data represents the identification information of the material (referred to as "material ID"). In addition, in the present embodiment, the game system 1 stores material information representing the properties and textures of the materials for each material prepared in the game (refer to Figure 7 ). In the present embodiment, the material information associates the material ID, the properties of the material, and the appearance of the material (specifically, the texture). Specifically, the material information is information that associates the material ID, the identification information of the properties of the material (referred to as "property ID"), and the identification information of the texture of the material (referred to as "texture ID") (refer to Figure 7 ).

[0127] Figure 8 is a diagram showing an example of property information representing the properties of the material. As Figure 8 shown, the game system 1 stores property information obtained by associating the above property ID with information representing the content of the property indicated by the property ID. The property of the material refers to the property that the voxel object with the material set has in the game (it can also be said to be a property that affects the progress of the game), for example, is Figure 8 shown information such as weight and slipperiness. In addition, in this specification, the property of the material means the meaning that does not include information related to the appearance such as the above texture. For example, as the property of the material, the following information can also be set.

[0128] · Temperature

[0129] · Vulnerability (for example, the number of times until the voxel object is destroyed when an impact is applied to the voxel object)

[0130] · Whether the voxel object adheres to other objects

[0131] · The amount of restoration of the player object's physical strength when the player object destroys the voxel object

[0132] · The amount of in-game currency obtained by the player object when the player object destroys the voxel object

[0133] In addition, the specific content of the properties set for the material is arbitrary. In other embodiments, as information representing the properties of the material, information different from the above may also be set.

[0134] Figure 9 FIG. is an example of texture information showing the texture representing the material. As Figure 9 shown, the game system 1 stores texture information obtained by associating the above texture ID with the texture indicated by the texture ID.

[0135] In addition, as data for specifying the appearance of the voxel object, in addition to the texture information, any information related to color and / or pattern may be set. For example, as information related to the appearance of the voxel object, a crack pattern may also be set. By using such a pattern, the game system 1 can generate an image of a voxel object that represents an appearance with cracks added.

[0136] As described above, in the present embodiment, the material data specifies the properties of the voxel object and the texture for the voxel object through the material ID. For example, when the material ID shown in the material data included in the voxel data is "002", the property indicated by the property ID "001" associated with the material ID in the material information is set as the property of the voxel object corresponding to the voxel data (refer to the arrow shown in Figure 7 ). In addition, in the above case, the texture indicated by the texture ID "002" associated with the material ID in the material information is applied to the voxel object corresponding to the voxel data (refer to the arrow shown in Figure 7 ).

[0137] As described above, in the present embodiment, the game system 1 manages the properties and textures of the material separately. Therefore, in the present embodiment, by setting a group of properties and textures in the material information, it is possible to easily set multiple types of materials with the same properties but different appearances (i.e., textures), and multiple types of materials with different properties but the same appearance.

[0138] In addition, the material data may be any data that can be used to determine the properties and / or textures of the material. For example, in other embodiments, the material data may also be data representing the above property ID and texture ID, and may also have a data structure that actually includes data representing the properties and textures of the material.

[0139] In addition, the material data is information related to the material, and can also represent other information different from the above-mentioned properties and textures. For example, the material data can also include effect data representing the effects that occur when the effect occurrence conditions set for the voxel object are satisfied (for example, a part of the voxel object is destroyed, or a character steps on the voxel object). In addition, the effect data can be data representing an effect image (for example, an effect image showing the destruction of the voxel object), or can also be data representing an effect sound (the sound of footsteps when a character walks on the voxel object).

[0140] As Figure 7 shown, the voxel data includes state data representing the state of the voxel object. The specific content of the state data is arbitrary. For example, the state data can be data representing whether the voxel object is wet, or can be data representing the amount of damage applied to the voxel object. The content of the state data can sometimes be updated in the game.

[0141] [2-2. Mesh]

[0142] In the present embodiment, the surface of the voxel object is represented by a mesh. A mesh refers to a collection of a plurality of faces (specifically, polygons) arranged in the game space. In the present embodiment, the game system 1 generates a mesh of the voxel object based on the voxel data of each voxel set in the game space. Hereinafter, an example of generating a mesh based on the voxel data will be described.

[0143] Figure 10 is a diagram showing an example of a mesh generation method. In addition, in Figure 10 , for the purpose of making the drawings easy to view and the description easy to understand, the voxels and the mesh are two-dimensionally represented, but in fact, a three-dimensional mesh is generated based on the voxels in the three-dimensional space.

[0144] As described above, in the present embodiment, the density set for the voxels is in the range of 0 to 255. In addition, in the present embodiment, voxels with a density equal to or higher than the reference value are considered to be inside the object, and voxels with a density lower than the reference value are considered to be outside the object. It is not necessary to define only voxels with a density of 0 as outside the object (i.e., the reference value = 1), and this reference value is set to 128, for example. In Figure 10In the example shown, the density is set to 0 in voxel 201 and other voxels on the outside, the density of voxel 202 is set to 100 which is lower than the reference value, and the densities in voxels 203 and 204 are set to 150 and 200 which are above the reference value. In the present embodiment, the game system 1 generates vertices between voxels with a density above the reference value and voxels with a density less than the reference value. Specifically, a determination of whether to generate vertices is made for each region spanning eight (four in the drawing) adjacent voxels (the region surrounded by dotted lines in the drawing). That is, vertices are generated in a region that spans both voxels with a density above the reference value and voxels with a density less than the reference value. And when passing between adjacent vertices (the boundaries of the above-mentioned regions each containing a vertex) through the boundary between a voxel with a density above the reference value and a voxel with a density less than the reference value, these vertices are connected to generate a polygon mesh. The densities of adjacent voxels are compared for each of the X, Y, and Z axes, and the coordinates of the vertices are determined by interpolation based on the density difference. At this time, coordinate calculation can also be performed based on normal information, but it can also be that normal information is pre-held for at least some voxels, and in the case where normal information is not held, the normal information can also be calculated based on the densities of adjacent voxels to each other. In addition, in Figure 10 since the density of voxel 202 is lower than the reference value, voxel 202 is regarded as outside the object in the determination of the presence or absence of vertices, but the density value of voxel 202 itself is used for the coordinate calculation of the generated vertices. Assuming that the reference value is set to a value lower than the density of voxel 202, as a result, in Figure 10 vertices are further increased at the upper right and upper left sides of voxel 202.

[0145] By generating a polygon mesh as described above, a shape of a volume that to some extent reflects the density of each voxel can be generated. However, depending on the relationship with adjacent voxels, there are sometimes cases where a voxel with a density of 0 contains a region inside a part of the object, or a voxel with a density of 255 contains a region outside a part of the object. In addition, in the present embodiment, voxels with a density lower than the reference value are treated as outside the object, so compared to the case of treating them as inside the object, the number of vertices is reduced, and correspondingly the volume is also reduced. That is, there is no need to calculate the polygon mesh in such a way that it becomes a volume strictly corresponding to the density value.

[0146] Figure 11 is a diagram showing an example of a game image including a terrain object. In the present embodiment, by generating a mesh as described above, the voxel object can be made into a shape with unevenness that is more complex than the length of one side of a voxel, for example.

[0147] In addition, the method of generating a mesh based on voxel data is arbitrary. For example, in other embodiments, a mesh may also be generated by arranging a cube for a voxel corresponding to the voxel data when the density of the voxel data is greater than a specified value (see Figure 4 ).

[0148] For each face of the mesh generated as described above, the game system 1 determines the appearance (i.e., color and / or pattern) of each face according to the material determined from the voxel data. Specifically, the game system 1 determines the texture for rendering each face of the mesh based on the voxel data, and maps the determined texture onto each face, thereby generating an image of the voxel object. In addition, the texture mapped onto each face of the mesh is determined based on the voxel data of the voxel (referred to as the generation target voxel) used to generate the face among the voxels where the voxel object exists. In addition, although it also depends on the mesh generation method, the generation target voxel is, for example, one or more voxels arranged around the face. That is, the texture mapped onto the face of the mesh is determined as a texture corresponding to the material set for one or more voxels arranged around the face.

[0149] In addition, in other embodiments, multiple types (e.g., two types) of material data may be included in one voxel data. In this case, the voxel data includes ratio data related to the multiple types of material data. The ratio data is data for determining the texture for the voxel object, and represents the ratio of the influence of each material (specifically, the texture corresponding to the material) indicated by the multiple types of material data on the appearance (specifically, color and / or pattern) of the voxel object. In addition, when determining the texture mapped onto each face of the mesh, the texture is determined based on various data (specifically, density data, multiple types of material data, and ratio data) included in the voxel data of the generation target voxel. For example, when multiple types of materials are set for the generation target voxel corresponding to one face, either the texture corresponding to the material with the greatest influence degree (one type) can be used considering the above ratio, or the textures corresponding to the multiple types of materials can be used considering the above ratio.

[0150] In addition, in other embodiments, there may be both voxel objects using voxel data including one type of material data and voxel objects using voxel data including two types of material data.

[0151] As described above, in the present embodiment, the game system 1 sets the color and / or pattern of the mesh of the voxel object based on appearance data (specifically, texture IDs representing textures) that specify voxel objects for each voxel. Specifically, the game system 1 applies the texture shown in the appearance data related to a certain voxel to the mesh generated from the voxel data of the voxel in the mesh of the voxel object. Accordingly, it is possible to set the color and / or pattern of the voxel object using the appearance data set for the voxel.

[0152] [2-3. Fragment Object]

[0153] Next, a case of generating a fragment object for a terrain object as a voxel object will be described. Figure 12 It is a diagram showing an example of a situation where a player object punches a terrain object. Figure 13 It is a diagram showing an example of a terrain object after a part of it has been destroyed due to the punching action of the player object. As Figure 12 and Figure 13 shown, in the present embodiment, when an impact is applied to the terrain object 212 due to a punching action or the like by the player object 211, the terrain object 212 is destroyed, and as a result, a part of the terrain object 212 may be eliminated. Hereinafter, an event in which a part of the terrain object 212 is eliminated will be referred to as an elimination event. The elimination event is not limited to occurring due to a punching action by the player object 211, and may also occur due to other actions by the player object 211 or a collision event in which another object collides with the terrain object 212.

[0154] In the present embodiment, when the terrain object 212 is eliminated, a fragment object 213 that represents the fragments of the terrain object 212 may be generated (see Figure 13 ). For example, when the terrain object 212 represents a rock field as Figure 13 shown, a fragment object 213 that imitates fragments of a rock is generated. In this way, by causing the fragment object to appear in the game space when the terrain object is eliminated, the game system 1 can more realistically represent the situation where the terrain object is destroyed.

[0155] [2-3-1. Main Voxel Space and Sub-Voxel Space]

[0156] In the present embodiment, the above-described fragment object is a voxel object whose shape is defined by voxel data, just like the terrain object. However, in the present embodiment, the shape of the fragment object is defined by voxel data related to voxels different from those of the terrain object. Hereinafter, the voxel space related to the terrain object is referred to as the "main voxel space", the voxels in the main voxel space are referred to as "main voxels", and the voxel data set for the main voxels is referred to as "main voxel data". On the other hand, the voxel space related to the fragment object is referred to as the "sub-voxel space", the voxels in the sub-voxel space are referred to as "sub-voxels", and the voxel data set for the sub-voxels is referred to as "sub-voxel data". In the present embodiment, the shape of the terrain object is defined by the main voxel data, and the shape of the fragment object is defined by the sub-voxel data.

[0157] Figure 14 FIG. is a diagram showing an example of a terrain object and a fragment object. In addition, in Figure 14 FIG., for the purpose of showing the difference between the main voxels and the sub-voxels in an easy-to-understand manner, voxel objects (i.e., the terrain object 221 and the fragment object 222) that are generated with a mesh according to the same rules as those for generating the mesh of the terrain object shown in Figure 4 FIG. are shown. That is, it is assumed that Figure 14 the voxel objects shown in FIG. are generated with a mesh according to the following rule: "When the density set for a voxel is greater than a specified value, a cube is arranged at the position of the voxel, and when it is equal to or less than the specified value, nothing is arranged at the position of the voxel." In addition, in Figure 14 FIG., for the purpose of making the drawing easy to view, the terrain object 221 is shown by a dotted line, the fragment object 222 is shown by a solid line, and the area 223 of the sub-voxel space is shown by a dashed line.

[0158] As described above, for the terrain object 221, its shape is defined by the main voxel data. In addition, in the present embodiment, it is assumed that the main voxel space is set for the entire game space (therefore, the range of the main voxel space is not shown in Figure 14 FIG.).

[0159] On the other hand, for the fragment object 222, its shape is defined by the sub-voxel data. Here, in the present embodiment, the sub-voxel space is set in a part of the game space (it can also be said to be a part of the main voxel space). In addition, in Figure 14 the example shown in FIG., the area 223 shown by the dashed line is the range where the sub-voxel space is set. The shape of the fragment object 222 is defined by the sub-voxel data set for each sub-voxel set in the sub-voxel space. The fragment object 222 is arranged within the range of the sub-voxel space.

[0160] In the present embodiment, the length of one side of the sub-voxel is set to be shorter than the length of one side of the main voxel (refer to Figure 14 ). That is, the game system 1 sets a sub-voxel space in which a voxel with a shorter side length than the main voxel is defined as a sub-voxel. Accordingly, the shape of the fragment object based on the sub-voxel data can be expressed more finely than the terrain object based on the main voxel data. For example, like the fragment object 222 shown in Figure 14 , it is easy to generate a fragment object smaller than one main voxel, and it is also easy to generate a fragment object with more delicate unevenness than one main voxel. In addition, in other embodiments, the length of one side of the sub-voxel may be the same as the length of one side of the main voxel, or may be longer than the length of one side of the main voxel.

[0161] In addition, in the present embodiment, the game system 1 independently sets the direction of the coordinate axes in the sub-voxel space (that is, the direction of each side of the sub-voxel) from the direction of the coordinate axes in the main voxel space (that is, the direction of each side of the main voxel). For example, in the example shown in Figure 14 , the direction of the coordinate axes in the sub-voxel space becomes a direction different from the direction of the coordinate axes in the main voxel space. Accordingly, it is easy to arrange the fragment object in a free direction in the game space. For example, it is easy to arrange the fragment object to extend in a direction different from the coordinate axes in the main voxel space. In addition, it is easy to move (for example, rotate) the fragment object independently of the terrain object.

[0162] In addition, the game system 1 can change the position of the fragment object (more precisely, the position in the game space) by changing the position of the sub-voxel space in the game space. In addition, the game system 1 can change the posture of the fragment object (more precisely, the posture in the game space) by changing the posture of the sub-voxel space based on the game space.

[0163] In the present embodiment, when generating a plurality of fragment objects, the game system 1 sets a sub-voxel space for each fragment object. Thus, the position and posture of each sub-voxel space in the game space can be set for each sub-voxel space. In addition, it is easy to generate a plurality of fragment objects having different shapes (for example, a plurality of fragment objects having shapes extending in different directions). In addition, the sub-voxel spaces may be arranged such that a part of one sub-voxel space overlaps with a part of another sub-voxel space. In addition, in other embodiments, a plurality of fragment objects may be set in one sub-voxel space.

[0164] In addition, the method for generating the mesh of the fragment object based on the sub-voxel data may be the same as or different from the method for generating the mesh of the terrain object based on the main voxel data.

[0165] [2-3-2. Elimination of Terrain Objects]

[0166] In this embodiment, when an impact application event occurs to a terrain object, the terrain object may be eliminated. An impact application event is an event that applies an impact to a terrain object. For example, it is a destruction action event in which a player object performs a destruction action on a terrain object, or a collision event in which another object (referred to as a collision object) collides with a terrain object. The above-mentioned destruction action is, for example, an action performed by a player object to destroy a terrain object, such as the boxing action described above. A collision event is, for example, an event in which, when a character such as a player object performs an action of holding and waving a collision object back and forth or throwing a collision object (these actions can also be said to be destruction actions), the collision object collides with the terrain object. In addition, the above-mentioned collision object can also be any object configured in the game space. For example, it can also be a weapon owned by a player object, and a fragment object can also function as a collision object (details will be described later).

[0167] In addition, the impact application events that may cause a terrain object to be eliminated are not limited to the above. For example, it can also be the case that when a player object can use a bomb as an item, as an impact application event, an event in which the bomb explodes near the terrain object, and the terrain object is eliminated according to this event.

[0168] In this embodiment, when the above-mentioned impact application event occurs, the game system 1 determines whether the elimination condition is satisfied. Here, in this embodiment, for a terrain object, an intensity is set for each voxel, and for an impact application event, an intensity is also set according to the type of the impact application event. The type of the impact application event is determined, for example, to be different according to the type of the destruction action performed in the impact application event or the type of the collision object that collides with the terrain object in the impact application event. The game system 1 determines whether the elimination condition is satisfied based on these intensities. In addition, in this embodiment, the intensity of the terrain object is set, for example, as one of the properties of the above-mentioned material. That is to say, the above-mentioned property ID can be said to be data representing the intensity of the terrain object. In this embodiment, it is set that the intensity can take an integer value from 1 to the upper limit value.

[0169] In addition, in this embodiment, the elimination condition is set according to the relationship between the intensity A of the destruction side (i.e., the impact application event) and the intensity B of the side to be destroyed (i.e., the terrain object). Specifically, the game system 1 determines the elimination condition as follows in (a) to (c) below.

[0170] (a) When the strength A on the destruction side is equal to or greater than the strength B on the damaged side (that is, when A ≥ B), it is determined that the elimination condition is satisfied.

[0171] (b) When the value obtained by adding 1 to the strength A on the destruction side is equal to the strength B on the damaged side (that is, when A + 1 = B), damage corresponding to the destruction action and the type of the collision object is inflicted on the terrain object. When the damage to the terrain object becomes equal to or greater than the reference value, it is determined that the elimination condition is satisfied.

[0172] (c) When the value obtained by adding 1 to the strength A on the destruction side is less than the strength B on the damaged side (that is, when A + 1 < B), no damage is inflicted on the terrain object (as a result, the elimination condition is not satisfied).

[0173] In addition, in the present embodiment, the damage to the terrain object is managed for each voxel. That is, the game system 1 stores data representing the above-mentioned damage value for each voxel as the above-mentioned state data included in the voxel data.

[0174] Based on the above, in the present embodiment, when the strength A on the destruction side is equal to or greater than the strength B on the damaged side (the above (a)), the elimination condition is satisfied due to the occurrence of the impact application event. In addition, when the strength A on the destruction side is slightly less than the strength B on the damaged side (the above (b)), the elimination condition is satisfied by the occurrence of a plurality of impact application events at the same position (that is, the same voxel) of the terrain object. That is, in this case, based on the occurrence of a certain number of impact application events on a certain part of the terrain object, that part is eliminated. In addition, when the strength A on the destruction side is significantly less than the strength B on the damaged side (the above (c)), the elimination condition is not satisfied even if the impact application event occurs.

[0175] The game system 1 determines the elimination condition for each voxel. Specifically, when an impact application event occurs, the elimination condition is determined for each voxel within the range corresponding to the impact application event based on the strength of the impact application event and the strength set for that voxel. In addition, the range corresponding to the impact application event is, for example, the influence range of the destruction action set according to the destruction action, or the influence range of the collision event set according to the type of the collision event. Specifically, when a boxing action is performed as the destruction action, the position where the player object's boxing hits the terrain object and a specified range including that position become the above-mentioned "range corresponding to the impact application event".

[0176] As described above, in the present embodiment, in the case of an impact application event in which an impact is applied to the main object (i.e., the terrain object), the game system 1 determines whether the elimination condition is satisfied (i.e., whether an elimination event occurs) based on the intensity of the impact application event set according to the type of the impact application event and the intensity indicated by the intensity data set for the main voxel to which the impact application event has been performed. Accordingly, even in the case of the same impact application event, whether an elimination event occurs varies depending on the intensity of the main object, or even in the case of an impact application event performed on the same main object, whether an elimination event occurs varies depending on the intensity of the impact application event. Thus, the occurrence of the elimination event corresponding to the impact application event can be made more natural.

[0177] When it is determined that the elimination condition is satisfied, the game system 1 executes an elimination event for eliminating a part of the terrain object. In the elimination event, the game system 1 sets the main voxels within the range corresponding to the impact application event as the voxels to be eliminated, and eliminates the terrain object within the voxels to be eliminated. Specifically, the game system 1 sets the density in the voxels to be eliminated to 0. In addition, the game system 1 eliminates a part of the terrain voxels for the voxels around the voxels to be eliminated (for example, the voxels partially overlapping with the above range, or the voxels adjacent to the voxels to be eliminated). Specifically, the game system 1 performs a subtraction operation on the density in the voxels around the voxels to be eliminated based on a prescribed rule. In addition, the content of this rule is arbitrary. For example, the game system 1 performs a subtraction operation on the density in the surrounding voxels in such a way as to avoid the shape of the terrain object after elimination from becoming an unnatural shape at the boundary between the voxels to be eliminated and the surrounding voxels.

[0178] In addition, the method of eliminating the terrain object in the elimination event is arbitrary. For example, in other embodiments, the game system 1 may also eliminate the terrain object only for the voxels to be eliminated within the range corresponding to the impact application event. In addition, for example, the game system 1 may also set the voxels at least partially included in the range corresponding to the impact application event as the voxels to be eliminated.

[0179] In addition, the size and / or shape of the above "range corresponding to the impact application event" may be set for each type of the impact application event. For example, it may be that the above range is set differently in the case where the impact application event is an event caused by a boxing action performed by a player object and in the case where the impact application event is an event caused by a specific collision object colliding with the terrain object.

[0180] [2-3-3. Debris Generation Conditions]

[0181] In the case of an elimination event occurring, the game system 1 determines whether the eliminated terrain object satisfies the fragment generation conditions. Here, in the present embodiment, the game system 1 stores fragment generation information indicating various information related to the generation of fragment objects, and performs processing related to the generation of fragment objects (for example, processing for determining fragment generation conditions and processing for generating fragments) based on this fragment generation information.

[0182] Figure 15 It is a diagram showing an example of fragment generation information. As Figure 15 shown, the fragment generation information associates the type of elimination event with various information related to the generation of fragment objects (specifically, fragment generation conditions, the size of fragment objects, and the upper limit number of fragment objects).

[0183] In Figure 15 the example shown, as examples of the types of elimination events, "normal punch", "strong punch", "swing fragment", "throw fragment", and "bomb" can be cited. "Normal punch" refers to an elimination event that occurs due to an impact application event based on a normal punching action performed by a player object. "Strong punch" refers to an elimination event that occurs due to an impact application event based on a punching action with higher power than normal performed by a player object. In this way, the type of elimination event (which can also be said to be the type of impact application event) differs according to the type of destruction action. In addition, "swing fragment" refers to an elimination event that occurs due to a collision event based on an action of a player object holding and swinging a fragment object as a collision object (that is, an action of swinging a fragment). "Throw fragment" refers to an elimination event that occurs due to a collision event based on an action of a player object throwing a fragment object as a collision object (that is, an action of throwing a fragment). In this way, the type of elimination event (which can also be said to be the type of impact application event) also differs according to the type of collision event. In addition, "bomb" refers to an elimination event that occurs due to the explosion of a bomb. As described above, the type of elimination event differs according to the type of impact application event.

[0184] In the present embodiment, as Figure 15 shown, the fragment generation information indicates the presence or absence of fragment generation conditions and the content of the fragment generation conditions for each type of elimination event. In Figure 15In the example shown, when the type of elimination event is "Normal Punch", the debris generation condition is "the strength of the side to be destroyed is 2 or more". That is, when an elimination event of "Normal Punch" occurs, if the strength of the side to be destroyed (i.e., the terrain object) is 2 or more, the game system 1 generates debris. Additionally, when the type of elimination event is "Swing Debris" or "Throw Debris", the debris generation condition is "the strength of the side to be destroyed is 2 or more, and the strength of the side to be destroyed is greater than the strength of the destroying side". Thus, in this embodiment, the content of the debris generation condition varies according to the type of elimination event.

[0185] In this embodiment, the strength of the side to be destroyed used for determining the debris generation condition is the strength set for the above-mentioned elimination target voxel (i.e., the strength represented by the property ID shown in the voxel data of the elimination target voxel). In addition, when the values of the strengths set for multiple elimination target voxels are of multiple types, the game system 1 can also determine the strength of the side to be destroyed based on these multiple types of strength values. For example, the game system 1 can also set the average value, minimum value, or maximum value of the multiple types of strength values as the strength of the side to be destroyed.

[0186] In addition, in Figure 15 the example shown, when the type of elimination event is "Strong Punch" or "Bomb", no debris generation condition is set. That is, when an elimination event of "Strong Punch" or "Bomb" occurs, the game system 1 does not generate debris. Thus, in this embodiment, it is determined whether to generate debris according to the type of elimination event. Additionally, in other embodiments, the following debris generation information can also be set: debris is always generated when a specific type of elimination event occurs.

[0187] As described above, in this embodiment, the content of the debris generation condition varies according to the type of elimination event. That is, the game system 1 sets the conditions used as the debris generation condition based on the type of elimination event that occurs. In addition, in this embodiment, whether to generate debris (i.e., the determination result of the debris generation condition) varies according to the type of elimination event. That is, the game system 1 performs the determination on whether the debris generation condition is satisfied based on the type of the above-mentioned elimination event that occurs. Additionally, in other embodiments, the game system 1 can also perform only one of the setting of the conditions used as the debris generation condition and the determination on whether the debris generation condition is satisfied based on the type of elimination event that occurs. According to the above, it is possible to make the conditions for generating debris vary corresponding to the type of elimination event. In addition, it is possible to set in detail the conditions for generating debris for each type of elimination event.

[0188] In addition, in the present embodiment, when an elimination event occurs due to an impact application event, the game system 1 determines the type of the elimination event based on the type of the impact application event. That is to say, it can also be said that the fragment generation conditions vary according to the type of the impact application event, and furthermore, it can also be said that whether fragments are generated varies according to the type of the impact application event. Therefore, in the present embodiment, it is possible to make the conditions for generating fragments vary corresponding to the type of the impact application event, and furthermore, it is possible to set in detail the conditions for generating fragments for each type of the impact application event.

[0189] In addition, in the present embodiment, when a first impact application event occurs due to the action of the player object causing the held collision object to collide with the main object (i.e., the action of waving a fragment), and when a second impact application event occurs due to the action of the player object causing the collision object to move toward the main object and collide with the main object (the action of throwing a fragment), the game system 1 determines that different types of elimination events have occurred. Accordingly, even when the same collision object collides with the main object, it is possible to make the generation result of the fragment object different according to the action performed by the player object.

[0190] In addition, in the present embodiment, the game system 1 determines whether the fragment generation conditions are satisfied based on the intensity corresponding to the type of the occurred elimination event (i.e., the intensity of the impact application event) and the intensity indicated by the property data set for the elimination target voxel where the elimination event has occurred. Even when the same elimination event is performed, the generation result of the fragment object varies according to the intensity of the main object, or even when the elimination event is performed on the same main object, the generation result of the fragment object varies according to the intensity of the elimination event. In this way, it is possible to make the generation result of the fragment object different according to the properties (specifically, the intensity) of the destruction side and the side to be destroyed. Thereby, it is possible to make the generation of the fragment object corresponding to the elimination event more natural.

[0191] [2-3-4. Generation of Fragment Object]

[0192] When the above-mentioned fragment generation conditions are satisfied, the game system 1 generates a fragment object. In the present embodiment, when generating a fragment object, first, the game system 1 determines the size level of the fragment object and the upper limit number of the fragment object. In the present embodiment, as Figure 15 shown, in the fragment generation information, the size level and the upper limit number of the fragment object are associated with each type of the elimination event. The game system 1 determines the size level and the upper limit number of the fragment object based on the type of the elimination event and the fragment generation information.

[0193] In addition, in the present embodiment, the size level of the fragmented object is determined to be any one of three levels: large, medium, and small. The game system 1 generates the fragmented object in such a way that the actually generated size of the fragmented object is within the range corresponding to the determined level. For example, when the size level is "large", the fragmented object is generated within the range of 160 to 300; when the size level is "medium", the fragmented object is generated within the range of 30 to 120; and when the size level is "small", the fragmented object is generated within the range of 5 to 12. In this way, in the present embodiment, the ranges corresponding to the respective levels are set not to overlap with each other. Thereby, it is possible to make it easy for the user to know which size level the generated fragmented object is. For example, when different processes are executed according to the size level of the fragmented object in the game, it is effective to easily know the size level of the generated fragmented object as described above.

[0194] Through the above, in the present embodiment, the game system 1 generates the sub-object (i.e., the fragmented object) in such a way that the sub-object (i.e., generates sub-voxel data) becomes a size corresponding to the type of the elimination event that has occurred. Accordingly, it is possible to make the size of the fragmented object different according to the type of the elimination event, and it is possible to set the size of the fragmented object in detail for each type of the elimination event. In addition, the game system 1 may determine the size based on other information instead of (or together with) the type of the elimination event. For example, in other embodiments, the size may also be determined based on the properties (e.g., strength) of the object on the destruction side and / or the object on the side to be destroyed.

[0195] In addition, in the present embodiment, the game system 1 determines the number (specifically, the upper limit number) of the sub-objects (i.e., the fragmented objects) to be generated based on the type of the elimination event that has occurred. Accordingly, it is possible to make the number of the generated fragmented objects change corresponding to the type of the elimination event. In addition, it is possible to set the number of the generated fragmented objects in detail for each type of the elimination event. In addition, the game system 1 may determine the number based on other information instead of (or together with) the type of the elimination event. For example, in other embodiments, the number may also be determined based on the properties (e.g., strength) of the object on the destruction side and / or the object on the side to be destroyed.

[0196] In other embodiments, the game system 1 may also determine other information related to the fragmented object based on the type of the elimination event and / or other information, instead of (or in addition to) determining the above-mentioned size level and number. For example, the direction in which the fragmented object scatters may also be determined based on the type of the elimination event.

[0197] When the size level and the upper limit number of the fragment objects are determined as described above, the game system 1 generates the fragment objects. In the present embodiment, the game system 1 generates the fragment objects based on the elimination part of the voxel object (specifically, by dividing the elimination part). Hereinafter, with reference to Figure 16 an example of a method for generating fragment candidate objects will be described.

[0198] Figure 16 FIG. is an example of a diagram showing a method for generating fragment objects. In the present embodiment, first, the game system 1 generates an elimination part object 231 corresponding to the elimination part eliminated by the elimination event in the terrain object (refer to Figure 16 the column (a) in). Next, the game system 1 generates a plurality of divided objects (four divided objects 232 to 235 in Figure 16 ) by dividing the elimination part object 231 (refer to Figure 16 the column (b) in). In addition, the specific method of division is arbitrary. For example, the elimination part object 231 may be divided by Voronoi Split. In addition, the game system 1 may also perform division based on the size level determined above (for example, such that at least a part of the divided objects is within the range corresponding to the level). Further, the game system 1 may also perform division based on the upper limit number determined above (for example, such that the number of divided objects is equal to the upper limit number, or is a number obtained by adding a specified number to the upper limit number).

[0199] Next, the game system 1 deletes a part of the divided objects 232 to 235 obtained by division as needed (refer to Figure 16 the column (c) in). Specifically, the game system 1 may delete the divided objects outside the range corresponding to the size level determined above among the divided objects 232 to 235. In addition, the game system 1 may also delete a part of the divided objects 232 to 235 so that the remaining divided objects are less than or equal to the upper limit number determined above. Further, in the example shown in Figure 16 , the divided object 235 among the four divided objects 232 to 235 is deleted. In the present embodiment, the undelete objects 232 to 234 among the divided objects 232 to 235 become the fragment objects. According to the above, the fragment objects can be generated in a manner that satisfies the determined size level and number. In addition, when the plurality of divided objects obtained by division satisfy the determined size level and number, the game system 1 may not perform the process of deleting the plurality of divided objects.

[0200] The above process of dividing the eliminated partial object can be performed using sub-voxel data or using a mesh. That is, the game system 1 can generate fragmented objects represented by sub-voxel data by dividing the eliminated partial object represented by sub-voxel data, or can generate fragmented objects composed of a mesh by dividing the eliminated partial object composed of a mesh. In the former case, for example, in order to generate a divided object by Voronoi division, a process of determining the generating point closest to each sub-voxel from a plurality of set generating points is performed for each sub-voxel, and by regarding one or more sub-voxels belonging to one generating point as one divided object, a divided object can be generated. At this time, the fragmented object after division is represented by sub-voxel data. On the other hand, in the latter case, since the fragmented object obtained by division is composed of a mesh, the game system 1 generates sub-voxel data of the fragmented object based on the mesh of the fragmented object.

[0201] As described above, in the present embodiment, when the game system 1 determines that the fragment generation condition is satisfied, it generates an eliminated partial object representing the eliminated part in the main object (i.e., the terrain object), and generates a sub-object (i.e., a fragmented object) by dividing the eliminated partial object into a plurality of parts. Accordingly, a fragmented object in accordance with the shape of the eliminated part of the main object can be generated.

[0202] In addition, the game system 1 generates sub-voxel data in the following manner: making the object within the range greater than the lower limit value and less than the upper limit value among the objects obtained by dividing the eliminated partial object into a plurality of parts ( Figure 16 the divided objects 232 to 235 shown) become sub-objects (i.e., fragmented objects). Thereby, the possibility of generating an overly large or overly small fragmented object can be reduced. In addition, by reducing the number of generated fragmented objects, the processing burden on the game system 1 can be alleviated.

[0203] As described above, in the present embodiment, when generating a plurality of fragmented objects, the game system 1 sets a sub-voxel space for each fragmented object. That is, when it is determined to generate a plurality of fragmented objects, the game system 1 generates sub-voxel data related to the fragmented object for each of the plurality of mutually independent sub-voxel spaces. And although the details will be described later, the game system 1 generates a mesh of the sub-object in the virtual space based on each sub-voxel data.

[0204] In addition, the game system 1 sets the sub-voxel space related to the fragment object as follows, for example. That is, the position of the sub-voxel space is set based on the position where the elimination event occurred (i.e., the position where the terrain object was eliminated). The posture of the sub-voxel space is set based on the direction of the eliminated part in the terrain object relative to the uneliminated part. The size of the sub-voxel space can be determined based on the type of the elimination event that is the main cause of generating the fragment object, or based on the size of the fragment object, or based on the nature (e.g., strength) of the object on the destruction side and / or the object on the side being destroyed.

[0205] In addition, in the present embodiment, it is assumed that the length of one side of the sub-voxel in each sub-voxel space related to each fragment object is predetermined and the same in each sub-voxel space. However, in other embodiments, the length of one side of the sub-voxel in each sub-voxel space can also be set for each fragment object. For example, in other embodiments, the length of one side of the sub-voxel can also be determined based on the type of the elimination event, or based on the size of the fragment object, or based on the nature (e.g., strength) of the object on the destruction side and / or the object on the side being destroyed.

[0206] In addition, for example, the length of one side of the sub-voxel can also be set to be different for each fragment object through the process described below. Specifically, when the size of the divided object obtained by dividing the eliminated partial object does not fall within the range of any of the above size levels, the game system 1 corrects the size of the divided object by enlarging or reducing it so that it becomes a value within the range of a certain level in the size level, and sets the corrected divided object as the fragment object. At this time, the game system 1 can also correct the size of the divided object by correcting the size of the sub-voxel space of the divided object. When correcting the size of the sub-voxel space in this way, the length of one side of the sub-voxel is different for each fragment object.

[0207] When generating the above-mentioned fragment object, the game system 1 generates a mesh not only for the terrain object as the main voxel object but also for the fragment object as the sub-voxel object. In addition, in the above case, when generating the game image, the game system 1 generates an image representing the game space including the main voxel object and the fragment object.

[0208] Here, in the present embodiment, for fragmented objects, materials (specifically, properties and textures) are set in the same way as for terrain objects. In the present embodiment, the materials of the fragmented objects are set based on the materials of the original terrain objects (specifically, the materials of the parts that are eliminated when generating the fragmented objects). Specifically, when there is one type of material in the eliminated part of the terrain object, the material of the fragmented object is set to be the same as the material of the original terrain object. That is, the properties of the fragmented object are set to be the same as the properties of the original terrain object, and the texture of the fragmented object is set to be the same as the texture of the original terrain object. In addition, when there are multiple types of materials in the eliminated part of the terrain object, the material of the fragmented object can be set to be the same as the material with the highest proportion included in the eliminated part, or the material of the fragmented object can be set to be the same as the material at the position where the impact application event occurred (for example, the position in contact with the collision object). Further, in other embodiments, the properties and / or textures of the fragmented object can also be set to be different from the properties and / or textures of the original terrain object based on the properties and / or textures of the original terrain object.

[0209] As described above, in the present embodiment, the game system 1 determines the appearance data (i.e., texture ID) set for the sub-voxels related to the sub-objects (i.e., fragmented objects) based on the appearance data set for the eliminated parts in the main object (i.e., terrain object). In addition, the game system 1 determines the property data (i.e., property ID) set for the sub-voxels related to the sub-objects (i.e., fragmented objects) based on the appearance data set for the eliminated parts in the main object (i.e., terrain object). Accordingly, fragmented objects having properties and / or appearances corresponding to the eliminated terrain objects can be generated.

[0210] In the present embodiment, the state data included in the sub-voxel data related to the fragmented objects is set to a predetermined initial value. However, in other embodiments, the state data related to the fragmented objects can also be set based on the content shown by the state data of the original terrain object (for example, in a way that is the same as that content).

[0211] In addition, when generating the fragmented objects, after the game system 1 makes the fragmented objects appear at the positions where the terrain objects in the game space are eliminated, the game system 1 moves the fragmented objects from those positions in the scattering directions. Thereby, the situation where the fragments scatter according to the destruction of the terrain objects can be shown. In addition, the above-mentioned scattering directions can be determined based on the types of the elimination events, or can be determined based on the properties of the objects on the destruction side and / or the damaged side, or can be determined as predetermined directions.

[0212] As described above, in the present embodiment, when the terrain object is eliminated and the fragment object is generated, the fragment object is arranged in the game space. Here, in the present embodiment, the player object can use the fragment object arranged in the game space to destroy the terrain object. That is, the player object can destroy the terrain object by the above-described action of waving the fragment or the action of throwing the fragment. In this way, in the present embodiment, the fragment object is used as the above-described collision object. Specifically, when an event in which a sub-object (i.e., the fragment object) collides with a main object (i.e., the terrain object) is performed as an impact application event, the game system 1 determines whether an elimination event has occurred. Accordingly, the player object can use the fragment object obtained by destroying the terrain object to further destroy the terrain object, so that the strategy of the game related to the destruction of the terrain object can be improved, and the fun of the game can be enhanced.

[0213] [2-3-5. Additional Terrain Objects Based on Fragment Objects]

[0214] Next, with reference to Figure 17 and Figure 18 the case of adding terrain objects by fragment objects will be described. Figure 17 is a diagram showing an example of a situation where a player object throws a fragment object at a terrain object. Figure 18 is a diagram showing an example of a situation where a terrain object is added as a result of the fragment object coming into contact with the terrain object. In the present embodiment, as shown in Figure 17 and Figure 18 , for example, as a result of the player object 241 throwing the fragment object 242 at the terrain object 243, the fragment object 242 may come into contact with the terrain object 243. In this case, under certain conditions, the game system 1 changes the shape of the terrain object 243 to a shape that combines the fragment object 242 with the terrain object 243 (that is, adds something corresponding to the fragment object 242 to the terrain object 243) (see Figure 18 ). Hereinafter, the process of adding terrain objects by fragment objects will be described.

[0215] When the fragment object comes into contact with the terrain object, first, the game system 1 determines whether the addition condition is satisfied. In addition, in the examples shown in Figure 17 and Figure 18 , as an example, a situation where the fragment object 242 comes into contact with the terrain object 243 due to the player object 241 throwing the fragment object 242 is shown, but the event that causes the fragment object to come into contact with the terrain object is arbitrary.

[0216] The specific content of the additional condition is arbitrary. For example, it can be a condition related to the materials of the two objects in contact (i.e., the debris object and the terrain object), or a condition related to the properties. Specifically, the additional condition can be that one or both of the objects have properties that can be added to other objects, or that the materials of the two objects in contact are a specific combination, or that the strengths of the two objects in contact are in a specified relationship. In addition, the additional condition is set so that the additional condition and the above elimination condition are not satisfied simultaneously.

[0217] When the additional condition is satisfied, the game system 1 changes the shape of the terrain object based on the contacted debris object so that the terrain object contacted by the debris object is added. That is, the game system 1 updates the main voxel data to change the shape of the terrain object.

[0218] Specifically, the game system 1 determines the voxel in the main voxel space to which the terrain object is to be added (referred to as the "addition target voxel"). The addition target voxel is determined based on the position where the debris object and the terrain object are in contact and the shape of the debris object. For example, the voxel corresponding to the position where the contact occurs and the voxel that overlaps with the debris object at the time of contact (that is, there is a debris object) become the addition target voxels.

[0219] For the determined addition target voxel, the game system 1 can also add the terrain object by increasing the density indicated by the voxel data. At this time, the game system 1 adjusts the value of the density to be increased so that the shape of the added part becomes a shape corresponding to the shape of the debris object. Thereby, the game system 1 can change the shape of the terrain object to make it a shape obtained by combining the debris object with the terrain object, and can represent the situation of combining the debris object with the terrain object.

[0220] In addition, the game system 1 deletes the debris object from the game space as the terrain object is added. In addition, due to the deletion of the debris object, the game system 1 also eliminates the sub-voxel space of the debris object itself (that is, does not set the sub-voxel space).

[0221] As described above, in the present embodiment, when the sub-object (i.e., the fragment object) collides with the main object (i.e., the terrain object), the game system 1 updates the main voxel data based on the sub-voxel data to add a part corresponding to the sub-object to the main object in the main voxel space. Accordingly, two objects with different voxel spaces (i.e., the terrain object and the fragment object) can be integrated into one object defined by the main voxel data. In addition, since the player object can not only eliminate the terrain object but also add the terrain object, options available to the player object in the game can be increased, and the strategy of the game can be improved.

[0222] [3. Specific Example of Processing in Game System]

[0223] Next, a specific example of the information processing in the game system 1 will be described with reference to Figures 19 to 22 FIG..

[0224] Figure 19 FIG. is an example of various data used in the information processing in the game system. As Figure 19 shown, the game system 1 stores a game program, main voxel space data, main voxel object data, main mesh data, sub-voxel space data, sub-voxel object data, and sub-mesh data. The game program and the main voxel space data are data pre-stored in the game system 1 before the game process is executed. The game program and the main voxel space data are stored, for example, in a storage medium in the slot 23 of the main device 2. In addition, the main voxel object data, the main mesh data, the sub-voxel space data, the sub-voxel object data, and the sub-mesh data are data generated during the execution of the game process. These data are stored, for example, in the DRAM 85 of the main device 2.

[0225] The game program is a game program for executing the game process in the present embodiment (specifically, Figure 20 the game process shown in FIG.).

[0226] The main voxel space data is data defining the main voxel space set in the game space. Specifically, the main voxel space data represents the length of one side of the main voxel and the direction of each side of the main voxel in the game space. In addition, when the main voxel space is set only in a part of the game space, the main voxel space data may also include data representing the position and size of the space where the main voxel is set (i.e., the main voxel space) (i.e., data representing the range of the main voxel set in the game space).

[0227] The main voxel object data is data representing the main object (i.e., the terrain object) disposed in the game space. Specifically, the main voxel object data includes the voxel data for each unit area within a part or all of the game space.

[0228] The main grid data is data representing a grid (i.e., the grid of the terrain object) set for the main object disposed in the game space. The main grid data includes, for example, data representing the positions of the respective vertices in the main grid.

[0229] The sub-voxel space data is data defining the sub-voxel space set in the game space. Specifically, the sub-voxel space data represents the position and size of the space (i.e., the sub-voxel space) where the sub-voxels are set, the length of one side of the sub-voxel, and the direction of each side of the sub-voxel in the game space.

[0230] The sub-voxel object data is data representing the sub-objects (i.e., fragment objects) disposed in the game space. Specifically, the sub-voxel object data includes sub-voxel data for each unit area within a part or all of the game space.

[0231] The sub-grid data is data representing a grid (i.e., the grid of the fragment object) set for the sub-object disposed in the game space. The sub-grid data includes, for example, data representing the positions of the respective vertices in the sub-grid.

[0232] In addition, in the present embodiment, a set of the above-described sub-voxel space data, sub-voxel object data, and sub-grid data is set for each sub-object. That is, when a plurality of sub-objects are disposed in the game space, the game system 1 stores the set for each sub-object.

[0233] In addition, the game system 1 stores, in addition to Figure 19 the data shown, data of the above-described property information and texture information, data of the above-described fragment generation information, and data related to various characters appearing in the game, etc., which are pre-stored in the game system 1 before executing the game process.

[0234] Figure 20 is a flowchart showing an example of the flow of the game process executed by the game system 1. Figure 20 The game process shown starts, for example, in response to an instruction from the player to start the game during the execution of the above-described game program.

[0235] In addition, in the present embodiment, it is assumed that the processor 81 of the main device 2 executes Figures 20 to 22 the processing of each step shown by executing the above-described game program stored in the game system 1 for explanation. However, in other embodiments, a part of the processing of each step shown may be executed by another processor (e.g., a dedicated circuit, etc.) other than the processor 81. In addition, when the game system 1 can communicate with other information processing devices (e.g., a server), the processing of Figures 20 to 22Part of the processing of each of the steps shown. Additionally, Figures 20 to 22 The processing of each of the steps shown is merely a simple example, and as long as the same result can be obtained, the order of the processing of each step can be swapped, and other processing can also be performed in addition to (or instead of) the processing of each step.

[0236] Additionally, the processor 81 uses a memory (e.g., DRAM 85) to execute Figures 20 to 22 the processing of each of the steps shown. That is, the processor 81 stores the information (in other words, data) obtained through each processing step into the memory, and when using this information in subsequent processing steps, reads out this information from the memory and utilizes this information.

[0237] In Figure 20 step S1 shown, the processor 81 sets the main voxel space in the game space. Specifically, the processor 81 acquires the above-mentioned main voxel space data and stores (in other words, writes) it into the DRAM 85. Additionally, in subsequent game processing, when the processor 81 executes processing related to terrain objects (e.g., the processing in step S2, etc.), it sometimes refers to the main voxel space data. In this case, the processor 81 refers to the main voxel space data stored in the DRAM 85. After step S1, the processing of step S2 is executed.

[0238] In step S2, the processor 81 sets the terrain object in the initial state in the game space. Specifically, the processor 81 acquires the voxel data representing the configuration of the terrain object in the initial state, and stores a part or all of the acquired voxel data as the main voxel object data into (in other words, writes) the DRAM 85. Additionally, the voxel data representing the configuration of the terrain object in the initial state is stored, for example, in the storage medium in the slot 23 of the main device 2. After step S2, the processing of step S3 is executed.

[0239] Furthermore, the voxel data written as the main voxel object data into the DRAM 85 can be the voxel data of a part of the range of the main voxel data in the entire range of the game space that is used to generate the game image. The processor 81 can also, for example, use the voxel data only for a part of the range in the game space (e.g., the range within a specified distance from the position of the virtual camera) to generate the image of the object. At this time, the main voxel object data can also include the voxel data within this range. Additionally, when writing the voxel data related to a part of the range in the game space, perform the same processing as step S2 at an appropriate timing during the execution of the series of processing in steps S4 - S10 described later (e.g., when the position of the virtual camera has moved more than a specified distance).

[0240] In step S3, the processor 81 generates a mesh for the terrain object. The mesh is generated according to the method described in the above "[2-2. Mesh]". Here, the processor 81 generates a mesh based on the main voxel object data stored in the DRAM 85 and stores it as main mesh data in the DRAM 85. Through the processing of step S3, the terrain object is constructed in the game space. After the above step S3, the game starts, and a series of processes of steps S4 to S10 are repeatedly executed during the game.

[0241] In step S4, the processor 81 controls the actions of various objects (e.g., player objects and enemy objects) that appear in the game space. For example, the processor 81 controls the actions of the player object based on the operation data received from each of the controllers 3 or 4, or controls the actions of the enemy object based on the algorithm determined in the game program. After step S4, the process of step S5 is executed.

[0242] In step S5, the processor 81 determines whether the above-described impact application event has occurred as a result of the above step S4. If the determination result in step S5 is affirmative, the process of step S6 is executed. On the other hand, if the determination result in step S5 is negative, the process of step S6 is skipped and the process of step S& is executed.

[0243] In step S6, the processor 81 executes an elimination process for eliminating a part of the terrain object. Hereinafter, the detailed process of the elimination process will be described with reference to Figure 21 to illustrate the detailed process.

[0244] Figure 21 is a sub-flowchart showing an example of the detailed process of the elimination process of step S6 shown in Figure 20 In the elimination process, first, in step S11, the processor 81 determines whether the result of the above step S4 satisfies the above-described elimination condition. In addition, as described above, the elimination condition is determined for each main voxel. Therefore, in the determination of step S4, if at least one main voxel satisfies the elimination condition, the determination result is affirmative. If the determination result in step S11 is affirmative, the process of step S12 is executed. On the other hand, if the determination result in step S11 is negative, the processor 81 ends Figure 21 the elimination process shown in

[0245] In step S12, the processor 81 updates the main voxel data stored in the DRAM 85 to eliminate a part of the terrain object. Specifically, the processor 81 eliminates a part of the terrain object by the method described in the above "[2-3-2. Elimination of Terrain Object]". After step S12, the process of step S13 is executed.

[0246] In step S13, the processor 81 updates the mesh for the terrain object whose main voxel data has been changed in step S12. That is, the processor 81 generates the mesh of the terrain object based on the main voxel object data updated in step S12. Thereby, the mesh of the terrain object can be dynamically changed in the game. In addition, the processor 81 updates the main mesh data stored in the DRAM 85 to the content representing the newly generated mesh. After step S13, the process of step S14 is executed.

[0247] In step S14, the processor 81 determines whether the result of the above step S4 satisfies the above-described fragment generation condition. Specifically, the processor 81 sets the fragment generation condition corresponding to the type of the elimination event according to the method described in the above "[2-3-3. Fragment Generation Condition]", and determines whether the set fragment generation condition is satisfied. When the determination result in step S14 is affirmative, the process of step S15 is executed. On the other hand, when the determination result in step S14 is negative, the processor 81 ends Figure 21 the elimination process shown.

[0248] In step S15, the processor 81 divides the above-described elimination partial object (refer to Figure 16 ). That is, first, the processor 81 determines the information on the size level and the upper limit number of the fragment objects, and executes the process of dividing the elimination partial object based on the determined information. The division process in step S15 is performed according to the method described in the above "[2-3-4. Generation of Fragment Objects]". After step S15, the process of step S16 is executed.

[0249] In step S16, the processor 81 sets the sub-voxel space related to the fragment object to be generated. The setting of the sub-voxel space is performed according to the method described in the above "[2-3-4. Generation of Fragment Objects]". At this time, the processor 81 stores the sub-voxel space data that defines the set sub-voxel space in the DRAM 85. After step S16, the process of step S17 is executed.

[0250] In step S17, the processor 81 generates the sub-voxel data representing the fragment object obtained by the division process in step S15. Specifically, the processor 81 generates the sub-voxel data of the sub-voxels in the sub-voxel space set in step S16, and the sub-voxel data represents the fragment object generated in step S15. In addition, the processor 81 stores the sub-voxel object data including the generated sub-voxel data in the DRAM 85. In addition, the sub-voxel data generated in step S17 only needs to include density data, and may not include material data and state data. After step S17, the process of step S18 is executed.

[0251] In step S18, the processor 81 sets the material and state of the generated fragment object. That is, the processor 81 sets the material and state of the fragment object according to the method described in the above "[2-3-4. Generation of Fragment Object]", and updates the sub-voxel data of the sub-voxel object data stored in the DRAM 85 to represent the set content. After step S18, the process of step S19 is executed.

[0252] In step S19, the processor 81 generates a mesh for the fragment object. For example, the processor 81 generates a mesh of the fragment object based on the sub-voxel data by the same method as the method of generating a mesh of the terrain object. The processor 81 stores the data representing the generated mesh of the fragment object as sub-mesh data in the DRAM 85. After step S19, the processor 81 ends Figure 21 the erasing process shown.

[0253] In addition, when a plurality of fragment objects are generated in the above step S15 (that is, there are a plurality of divided objects), the above series of processes of steps S16 to S19 are executed for the plurality of fragment objects.

[0254] Returning to Figure 20 the description, after the erasing process of step S6, the process of step S7 is executed. In step S7, the processor 81 determines whether the fragment object has come into contact with the terrain object as a result of the above step S4. If the determination result in step S7 is affirmative, the process of step S8 is executed. On the other hand, if the determination result in step S7 is negative, the process of step S8 is skipped, and the process of step S9 described later is executed.

[0255] In step S8, the processor 81 executes an addition process for adding a terrain object. Next, the detailed process of the addition process will be described with reference to Figure 22 to illustrate the detailed process flow of the addition process.

[0256] Figure 22 is a sub-flowchart showing Figure 20 an example of the detailed process flow of the addition process of step S8 shown. In the addition process, first, in step S21, the processor 81 determines whether the result of the above step S4 satisfies the above addition condition. If the determination result in step S21 is affirmative, the process of step S22 is executed. On the other hand, if the determination result in step S21 is negative, the processor 81 ends Figure 22 the addition process shown.

[0257] In step S22, the processor 81 updates the main voxel data based on the debris object that has come into contact with the terrain object to append the terrain object. Specifically, the processor 81 updates the main voxel data according to the method described in the above "[2-3-5. Appending the terrain object based on the debris object]". The processor 81 updates the main voxel object data stored in the DRAM 85 to include the updated main voxel data. After step S22, the process of step S23 is executed.

[0258] In step S23, the processor 81 deletes the debris object that has come into contact with the terrain object, and eliminates the sub-voxel space related to the debris object from the game space. That is, the processor 81 deletes the sub-voxel space data, sub-voxel object data, and sub-grid data related to the above debris object from the DRAM 85. After step S23, the processor 81 ends Figure 22 the appending process shown.

[0259] Return to Figure 20 the description. After the appending process in step S8, the process of step S9 is executed. In step S9, the processor 81 generates a game image representing the game space and causes the display device to display the game image. Specifically, the processor 81 generates a game image representing the game space including the voxel object and other objects (e.g., the player object and the enemy object). In addition, using the main voxel object data, main grid data, sub-voxel object data, and sub-grid data stored in the DRAM 85, the image of the voxel object is generated according to the method described in the above "[2-2. Grid]". The processor 81 causes the display device to display the generated game image. In addition, during the game, the process of step S9 is repeatedly executed at a rate of once per predetermined time (e.g., the time of one frame). After step S9, the process executed by S10 is performed.

[0260] In step S10, the processor 81 determines whether to end the game. For example, the processor 81 determines whether an instruction for ending the game has been given by the user. If the determination result in step S10 is negative, the process of step S4 is executed again. After that, the series of processes of steps S4 to S10 are repeatedly executed until it is determined in step S10 that the game is ended. On the other hand, if the determination result in step S10 is positive, the processor 81 ends Figure 20 the game process shown.

[0261] [4. Effects and Modification Examples of the Present Embodiment]

[0262] As described above, in the above embodiment, the information processing system (specifically, the game system 1) has the following structure.

[0263] · A main object generation unit that generates a mesh of a main object (i.e., a terrain object) in a virtual space based on main voxel data for each main voxel defined in a main voxel space that is a voxel space set in the virtual space (step S3).

[0264] · A main voxel update unit that, when an elimination event occurs for at least some of the multiple main voxels in the main voxel space, updates the main voxel data of the main voxel where the elimination event occurred, i.e., the elimination target voxel, so that at least the part of the main object corresponding to the elimination target voxel is eliminated (step S13).

[0265] · A fragment determination unit that, when an elimination event occurs, determines whether the fragment generation condition is satisfied based on the property data related to the elimination target voxel in the property data representing the property (specifically, intensity) of the main object for each main voxel (step S14).

[0266] · A sub-object generation unit that, when it is determined that the fragment generation condition is satisfied, generates voxel data of a sub-object (i.e., a fragment object), i.e., sub-voxel data, and generates a mesh of the sub-object in the virtual space based on the sub-voxel data, where the sub-voxel data is the voxel data for each sub-voxel defined in a sub-voxel space that is different from the main voxel space and is set in the virtual space (steps S17, S19).

[0267] · An image output unit that outputs an image of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device (step S9).

[0268] With the above structure, by using sub-voxel data related to a sub-voxel space different from the main voxel space to represent a sub-object that represents the fragments of the main voxel, it is possible to realistically represent the fragments when the main object is destroyed.

[0269] In addition, with the above structure, the fragment generation condition is determined based on the property data related to the elimination target voxel. Therefore, it is possible to make the generation of the sub-object representing the fragment different for each main object being eliminated, and also possible to make the generation of the sub-object representing the fragment different for each position of the part being eliminated in the main object. Thus, it is possible to more realistically represent the fragments when the main object is destroyed. In addition, in other embodiments, the game system 1 may also determine the fragment generation condition without relying on the above property data. For example, the game system 1 may determine the fragment generation condition based on the type of the above elimination event instead of the above property data.

[0270] In addition, in the above-described embodiment, the main object is a terrain object arranged in the virtual space. Here, in other embodiments, the main object can be any object in the virtual space. For example, the main object can also be a player object, an enemy object, or an object such as a vehicle that can be ridden by a player object, etc., which is an object that can move within the virtual space. In addition, the game system 1 can also set multiple types of objects as the main object respectively.

[0271] In the above-described embodiment, the determination of whether the voxel object contacts other objects (so-called hit determination) is performed in units of voxels. That is, when the other object (for example, the hit determination area set for the other object) is included in the voxel in the game space where the density is above a specified value, the game system 1 determines that the voxel object contacts the other object. Thereby, the processing burden of the hit determination can be reduced. However, in other embodiments, the game system 1 can also use the mesh of the voxel object to perform the hit determination. That is, it can also be that when the mesh of the voxel object contacts the other object, the game system 1 determines that the voxel object contacts the other object.

[0272] In addition, in other embodiments, the information processing system (specifically, the game system 1) may not have a part of the structure in the above-described embodiment, and may not execute a part of the processing executed in the above-described embodiment. For example, in order to achieve a part of the specific effects in the above-described embodiment, the information processing system only needs to have a structure for achieving the effect and execute the processing for achieving the effect, and may not have other structures and may not execute other processing.

[0273] The above-described embodiment aims to generate an object that represents a part where an object is damaged, etc., and can be utilized as a game system, a game program, for example.

Claims

1. A computer program product, comprising an information processing program executed in a computer of an information processing device, wherein the information processing program causes the computer to function as the following units: A main object generation unit that generates a mesh of a main object in the virtual space based on main voxel data of each main voxel defined in a main voxel space which is a voxel space set in the virtual space; A main voxel update unit that, when an elimination event occurs for at least a part of a plurality of the main voxels in the main voxel space, updates the main voxel data of the main voxel where the elimination event has occurred, that is, the eliminated target voxel, so that at least a part of the main object corresponding to the eliminated target voxel is eliminated; A fragment determination unit that, when the elimination event occurs, determines whether a fragment generation condition is satisfied based on property data related to the eliminated target voxel among property data representing the properties of the main object for each main voxel; A sub-object generation unit that, when it is determined that the fragment generation condition is satisfied, generates voxel data of a sub-object, that is, sub-voxel data, and generates a mesh of the sub-object in the virtual space based on the sub-voxel data, wherein the sub-voxel data is voxel data of each sub-voxel defined in a sub-voxel space which is a voxel space set in the virtual space and is different from the main voxel space; and An image output unit that outputs images of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device.

2. The computer program product according to claim 1, wherein the information processing program causes the computer to further function as an appearance setting unit that sets the color and / or pattern of the mesh of the main object based on appearance data defining the color and / or pattern of the main object for each main voxel.

3. The computer program product according to claim 2, wherein the appearance data is data representing a texture, and the appearance setting unit applies the texture represented by the appearance data related to a certain main voxel to the mesh of the main object generated based on the voxel data of the certain main voxel.

4. The computer program product according to claim 2 or 3, wherein the sub-object generation unit determines the appearance data set for the sub-voxels related to the sub-object based on the appearance data set for the eliminated part of the main object.

5. The computer program product according to any one of claims 1 to 4, wherein the sub-object generation unit determines the property data set for the sub-voxels related to the sub-object based on the property data set for the eliminated part of the main object.

6. The computer program product according to any one of claims 1 to 5, wherein The information processing program causes the computer to also function as a number determination unit that determines the number of the sub-objects to be generated based on the type of the elimination event that has occurred. In the case where it is determined that a plurality of the sub-objects are to be generated, the sub-object generation unit generates the sub-voxel data related to each of the plurality of mutually independent sub-voxel spaces, and generates a mesh of each of the sub-objects in the virtual space based on each of the sub-voxel data.

7. The computer program product according to any one of claims 1 to 6, wherein The fragment determination unit sets the conditions used as the fragment generation conditions and / or determines whether the fragment generation conditions are satisfied based on the type of the elimination event that has occurred.

8. The computer program product according to claim 7, wherein In the case where the elimination event has occurred due to an impact application event in which an impact is applied to the main object, the fragment determination unit discriminates the type of the elimination event based on the type of the impact application event.

9. The computer program product according to claim 8, wherein In the case where a first impact application event has occurred due to an action in which a collision object held by a player object collides with the main object, and in the case where a second impact application event has occurred due to an action in which the player object causes the collision object to collide with the main object by moving the collision object toward the main object, the fragment determination unit determines that different types of the elimination events have occurred.

10. The computer program product according to claim 8 or 9, wherein In the case where an event in which a sub-object collides with the main object is performed as the impact application event, the fragment determination unit determines whether the elimination event has occurred.

11. The computer program product according to any one of claims 1 to 10, wherein The property data represents the strength of the main object. The fragment determination unit determines whether the fragment generation conditions are satisfied based on the strength corresponding to the type of the elimination event that has occurred and the strength represented by the property data set for the elimination object voxel in which the elimination event has occurred.

12. The computer program product according to any one of claims 1 to 11, wherein The property data represents the strength of the main object. In the case where an impact application event in which an impact is applied to the main object has been performed, the fragment determination unit determines whether the elimination event has occurred based on the strength of the impact application event set according to the type of the impact application event and the strength represented by the property data set for the main voxel to which the impact application event has been applied.

13. The computer program product according to any one of claims 1 to 12, wherein The sub-object generation unit generates the sub-voxel data in such a manner as to form the sub-objects having a size corresponding to the type of the elimination event that has occurred.

14. The computer program product according to any one of claims 1 to 13, wherein in a case where it is determined that the fragment generation condition is satisfied, the sub-object generation unit generates an elimination part object representing an eliminated part in the main object, and generates the sub-object by dividing the elimination part object into a plurality of parts.

15. The computer program product according to claim 14, wherein the sub-object generation unit generates the sub-voxel data in such a manner that an object within a range greater than a lower limit value and less than an upper limit value among the objects obtained by dividing the elimination part object into a plurality of parts becomes the sub-object.

16. The computer program product according to any one of claims 1 to 15, wherein in a case where the sub-object collides with the main object, the main object generation unit updates the main voxel data based on the sub-voxel data to add a part corresponding to the sub-object to the main object in the main voxel space.

17. The computer program product according to any one of claims 1 to 16, wherein the sub-object generation unit sets a sub-voxel space in which a voxel shorter in length by one side than the main voxel is defined as the sub-voxel.

18. The computer program product according to any one of claims 1 to 17, wherein the sub-object generation unit sets the direction of the coordinate axis in the sub-voxel space independently of the direction of the coordinate axis in the main voxel space.

19. The computer program product according to any one of claims 1 to 18, wherein the main object is a terrain object disposed in the virtual space.

20. An information processing system, comprising: a main object generation unit that generates a mesh of a main object in the virtual space based on main voxel data of each main voxel defined in a main voxel space that is a voxel space defined in the virtual space; a main voxel update unit that, in a case where an elimination event has occurred for at least a part of a plurality of the main voxels in the main voxel space, updates the main voxel data of the elimination object voxel, which is the main voxel for which the elimination event has occurred, so that at least a part of the main object corresponding to the elimination object voxel is eliminated; a fragment determination unit that, in a case where the elimination event has occurred, determines whether the fragment generation condition is satisfied based on property data related to the elimination object voxel among property data representing the property of the main object for each main voxel; a sub-object generation unit that, in a case where it is determined that the fragment generation condition is satisfied, generates sub-voxel data of a sub-object, i.e., sub-voxel data, and generates a mesh of the sub-object in the virtual space based on the sub-voxel data, wherein the sub-voxel data is voxel data of each sub-voxel defined in a sub-voxel space that is a voxel space defined in the virtual space and different from the main voxel space; and An image output unit that outputs an image of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device.

21. An information processing apparatus comprising: A main object generation unit that generates a mesh of a main object in the virtual space based on voxel data of each main voxel defined in a main voxel space that is a voxel space set in the virtual space; A main voxel update unit that, when an elimination event occurs for at least a part of a plurality of the main voxels in the main voxel space, updates the voxel data of the main voxel for which the elimination event has occurred, that is, the elimination target voxel, so that at least a part of the main object corresponding to the elimination target voxel is eliminated; A fragment determination unit that, when the elimination event occurs, determines whether a fragment generation condition is satisfied based on the property data related to the elimination target voxel among the property data representing the property of the main object for each main voxel; A sub-object generation unit that, when it is determined that the fragment generation condition is satisfied, generates voxel data of a sub-object, that is, sub-voxel data, and generates a mesh of the sub-object in the virtual space based on the sub-voxel data, where the sub-voxel data is voxel data of each sub-voxel defined in a sub-voxel space that is a voxel space set in the virtual space and different from the main voxel space; And An image output unit that outputs an image of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device.

22. An information processing method executed by an information processing system, the information processing method including: A main object generation step of generating a mesh of a main object in the virtual space based on voxel data of each main voxel defined in a main voxel space that is a voxel space set in the virtual space; A main voxel update step of, when an elimination event occurs for at least a part of a plurality of the main voxels in the main voxel space, updating the voxel data of the main voxel for which the elimination event has occurred, that is, the elimination target voxel, so that at least a part of the main object corresponding to the elimination target voxel is eliminated; A fragment determination step of, when the elimination event occurs, determining whether a fragment generation condition is satisfied based on the property data related to the elimination target voxel among the property data representing the property of the main object for each main voxel; A sub-object generation step of, when it is determined that the fragment generation condition is satisfied, generating voxel data of a sub-object, that is, sub-voxel data, and generating a mesh of the sub-object in the virtual space based on the sub-voxel data, where the sub-voxel data is voxel data of each sub-voxel defined in a sub-voxel space that is a voxel space set in the virtual space and different from the main voxel space; And An image output step of outputting an image of the mesh of the main object and the mesh of the sub-object in the virtual space to a display device.

Images