粒子

For complex things in GameMaker Studio 2 you would normally have an object and create instances of that object around the room. 然而，对于图形效果，这可能是昂贵的消耗，因为每个实例在处理中由于其包含的变量以及它在不同事件中写入的代码而具有“成本”。You can reduce this cost by turning to tilemap layers and asset layers for drawing your graphics needs but those are generally static and cannot be changed or moved around much. However, there is one other option for drawing fast yet versatile graphics effects in your games, and that is to use particles.

Particles are graphic resources that have certain properties which are defined within a particle system. These properties cannot be manipulated directly for individual particles, but are changed through the code that is used to define the individual particle and the system that it belongs to. They are very useful for creating beautiful and flashy effects (or subtle and discreet ones!) like explosions, decals, rain, snow, star fields and debris in a game without the CPU overhead that using instances has.

The basic setup for a particle system follows three steps, with the third step being optional depending on how you wish to create your particle effects within the room:

• Create a particle system: The particle system is like a container that we will use to hold our different particle types ready for use. We use code to define a series of visual aspects and behaviours for our particles, and then we place them in the "container" so that we can take them out and use them whenever and wherever we need later.
• 
  
• Create particle types: Particle types are the graphic effect itself. You can have many different types, each with their own range of colours, alphas, sizes and movements, but its important to note that you do not have control over individual particles. 你可以定义一系列参数，创建的粒子将从中选择一些随机的行为并且散布开来。
• 
  
• Create emitters: Emitters are an option that can be used to burst or stream particles from within very clearly defined limits. They are optional because you can create particles from any instance using the part_particles_create and part_particles_create_colour functions but they are not always adequate for every situation.

Although particles are an excellent tool for creating effects, they do come with certain restrictions and good practices which need to be followed unless you want your game to grind to halt and eventually crash:

• Particle systems, particles and emitters take up memory and as such you should be very careful how you use them as it is very easy to cause a memory leak which will slow down and eventually crash your game. One way to cope with this is to have a global system with everything defined at the start of the game and removed at the end, but if you want a dynamic system then each particle and emitter (and the system itself) should be destroyed the moment it is not needed.
• 
  
• Particles may be fast and light on the CPU, but they still require some processing and so you shouldn't have 40,000 of them bursting across the screen at a time. 将它们限制为实现特定效果所必需的个数，而不是更多。
• 
  
• 如果你是定义自己的粒子精灵而不是使用14个精灵中的一个，在实现你需要的效果的前提下，你应该让它们尽可能的小。
• 
  
• 粒子不会与任何事物交互。如果你需要它们与用户或游戏中的任何其他实例进行任何类型的交互，你应该考虑使用实例，因为粒子是纯粹的图形。
• 
  
• Even though there is no technical limit to the amount of systems, emitters and particles you can create in one game, you should try and limit everything to the minimum number possible to keep memory use as low as possible.
• 
  
• On mobile devices, take care with particles as drawing them can be slow if they cover a large area of the screen (over-draw on mobile devices is one of the main causes of slowdown).
• 
  
• With HTML5 there is no additive blending, and unless you have WebGL enabled, you cannot have colour blending either.
• 
  

The following sections cover all aspects of coding your own particle systems:

Simple Particle Effects

The easiest way of creating particles in your game with GameMaker Studio 2 is to use the in-built effects mechanism. There effects are created using an internal particle system which is basically a very fast method for drawing graphical effects only and as such you do not have to worry about all the details (like memory management) when using these functions. You simply specify the type of effect, the position where it must be created, the size you want it to be and finally, its colour then let GameMaker Studio 2 do all the work.

The following functions exists for creating the built in particle effects:

• effect_create_below
  
• effect_create_above
  
• effect_clear
  

There are also a number of different constants for each of the pre-defined effects that the above functions can use:

• ef_cloud
  
• ef_ellipse
  
• ef_explosion
  
• ef_firework
  
• ef_flare
  
• ef_rain
  
• ef_ring
  
• ef_smoke
  
• ef_smokeup
  
• ef_snow
  
• ef_spark
  
• ef_star
  

Even though these effects are limited in scope and customisation, they can still be used to create some simple, great effects with very little effort. For example by creating a small puff of grey smoke below a moving missile in each step, a pretty convincing smoke trail is created, so even when you are an expert in particles it pays to remember that these effects exists as they can still save you some time.

Particle Systems

Before you can create particles you need to create a particle system. This is a "container" where you place your particles and emitters (if you need them) ready for use, and you can put as many or as few particles into any one system as you think necessary, and you can have as many systems as you think necessary too. However, it is always better to keep this number as small as possible due to the fact that each system, emitter and particle takes up memory and having too many of them may slow your game down or cause problems. For example, if you need some effects to appear above instances, and other effects to appear beneath instances, you would create two systems and set their depths to get the desired effect, with all particles that are added to each system being drawn at the depth you specify.

System Functions

Since a particle system is a dynamically created resource, you must create it and store the returned index in a variable to reference the system in all further function calls, and it is very important that you also destroy the system when it is no longer needed or else you will have a memory leak that will slow down and eventually crash your game. It is also worth noting that particle systems will live on forever after they are created, even if the index is no longer stored. So even if you change room or restart the game, the systems and the particles will remain, and be visible, in all further rooms so you better make sure you destroy them once you no longer need them.

The basic functions for setting up a particle system are listed below:

• part_system_exists
  
• part_system_create
  
• part_system_create_layer
  
• part_system_get_layer
  
• part_system_layer
  
• part_system_clear
  
• part_system_depth
  
• part_system_position
  
• part_system_destroy
  
• part_particles_clear
  
• part_particles_count
  

System Drawing

Once particles are added to a particle system and then burst or streamed into the room, they are normally automatically updated each step and drawn based on the parameters that you have used to define them. However it can sometimes be necessary to control when and how the system is updated as well as how the system should be drawn, and for that GameMaker Studio 2 provides the following functions:

• part_system_automatic_update
  
• part_system_automatic_draw
  
• part_system_update
  
• part_system_drawit
  
• part_system_draw_order
  

Creating Particles Directly

Normally you would use particle emitters to burst or stream particles from an area, but in many cases these are not necessary and it is actually better to just create the particles directly using the following functions:

• part_particles_create
  
• part_particles_create_colour
  

Particle Types

Particles are the graphic effects that can be created by the use of particle systems in a game. The particles that you define using these functions can be used in any system that you create and the normal procedure would be to define all your particles once at the start of a game and store their index values in global variables. These global variables can then be used to burst, emit or create particles at any time throughout the game. You can also create, use and then destroy particles as needed if memory is an issue or if you wish many different types but only at specific points in your game. Whatever you choose, particles are a very versatile resource!

Particles need to be created and have their index stored in a variable so that all further particle routines can access them correctly. The following functions are used to create, check for, clear and destroy particle types:

• part_type_exists
  
• part_type_create
  
• part_type_destroy
  
• part_type_clear
  

Once you have created your particle type you should give it a shape. This can be one of the 14 built in shapes which are 64x64 pixel sprites with alpha blending, or you can use your own sprites which can be animated, static or use random sub-images. The following functions define the visual base shape of each particle:

• part_type_shape
  
• part_type_sprite
  

The following image shows the 14 built in particle types that you can choose from:

Once you have chosen the sprite for the particle type (either a default shape or your own) you can indicate the size and scale of it. The size can be specified as a range and all particles will be created with a size chosen from within the given range. The scale is the "base" value for the x and y axis scale of the particle before any size variations are added and the following functions are used to control these values:

• part_type_size
  
• part_type_scale
  

Particles can also have an orientation and motion. As with most particle functions, the speed, direction and orientation are resolved as a random value that is selected from a given range and can be set with the following functions:

• part_type_speed
  
• part_type_direction
  
• part_type_gravity
  
• part_type_orientation
  

Once you have the style and movement of your particles sorted out, you can then set their colour and alpha values, both of which can be set as an absolute value during the whole lifespan of the particle, or as a scale of values that go from one to the other gradually. Note that there is also a special function that permits you to set the blending for particles and their surroundings, and this can be either normal or additive and gives some fantastic effects- The functions governing colour, alpha and blending are:

• part_type_colour_mix
  
• part_type_colour_rgb
  
• part_type_colour_hsv
  
• part_type_colour1
  
• part_type_colour2
  
• part_type_colour3
  
• part_type_alpha1
  
• part_type_alpha2
  
• part_type_alpha3
  
• part_type_blend
  

Particles exist on-screen for a limited amount of time and this is called their "lifetime". Particle lifetimes are measured in steps and (like previous functions) this is expressed as a range of values from which the particle will be given a specific lifetime. There are also a couple of interesting functions which can be used to make particles generate other particles, either each step or when they "die" (ie: Are removed from the screen), but be very careful with these functions as they can quickly create thousands of particles and crash the game! The functions that set lifetime and step or death emitting are as follows:

• part_type_life
  
• part_type_step
  
• part_type_death
  

It is worth noting that creating particles through code can often be a laborious and time-consuming process due to the large number of parameters that can be changed and tweaked. For that reason it is recommended that you search around and get a hold of some type of Particle Designer (or make one yourself!) to take the drudgery out of particle creation.

粒子发射器

Emitters are used by GameMaker Studio 2 to emit particles over an area of the screen which can have different forms and distributions. They can also either create a continuous stream of particles or they can burst out a number of particles all at once, depending on the way the functions are used.

Since a particle emitter is a dynamically created resource, you must create it and store the returned index in a variable to reference the emitter in all further function calls, and it is very important that you also destroy the emitter when it is no longer needed or else you will have a memory leak that will slow down and eventually crash your game. It is also worth noting that particle emitters will live on forever after they are created, even if the index is no longer stored. So even if you change room or restart the game, the systems and the particles will remain, and be visible, in all further rooms so you better make sure you destroy them once you no longer need them.

The following functions are available to set the emitters and to let them create particles. Note that each of them gets the index of the particle system to which it belongs as a first argument.

• part_emitter_exists
  
• part_emitter_create
  
• part_emitter_clear
  
• part_emitter_region
  
• part_emitter_burst
  
• part_emitter_stream
  
• part_emitter_destroy
  
• part_emitter_destroy_all
  

© Copyright YoYo Games Ltd. 2018 All Rights Reserved