UnigineScript
The Language
Core Library
Engine Library
Node-Related Classes
GUI-Related Classes
Plugins Library
High-Level Systems
Samples
Usage Examples
C++ API
API Reference
Integration Samples
Usage Examples
C++ Plugins
Migration
Migrating to UNIGINE 2.0
C++ API Migration
Migrating from UNIGINE 2.0 to UNIGINE 2.1

engine.game Functions

See Also

string engine.game.getData ()

Returns user data associated with the game. This string is written directly into a *.world file. Namely, into the data child tag of the game tag, for example:
Source code (XML)
<world version="1.21">
	<game>
		<data>User data</data>
	</game>
</world>

Return value

User data. Data can contain an XML formatted string.

float engine.game.getFTime ()

Returns time spent between a previous update and a current one. This function takes time scaling into account.

Return value

Frame duration in seconds.

int engine.game.getFrame ()

Returns the current game frame.

Return value

Frame number.

float engine.game.getIFps ()

Returns a scaled fixed frame duration.

Return value

Frame duration in seconds (1 / FPS). If the game is paused, 0.

Obstacle engine.game.getIntersection (vec3 p0, vec3 p1, float radius, int mask, GameIntersection intersection)

Performs intersection to find if a pathfinding obstacle is located within the cylinder between two points.

Notice
World space coordinates are used for this function.

Usage Example

The following example shows how you can get the intersection point (vec3) of the cylinder between two points with an obstacle. In this example the cylinder is an invisible traced cylinder from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1) with the specific radius. The executing sequence is the following:

  • Define and initialize two points (p0 and p1) by using the Unigine::getPlayerMouseDirection() function from core/scripts/utils.h.
  • Create an instance of the GameIntersection class to get the intersection point coordinates.
  • Check, if there is a intersection with an obstacle. The engine.game.getIntersection() function returns an intersected obstacle when the obstacle appears in the area of the cylinder.
  • After that GameIntersection instance gets the point of the nearest intersection point and you can get it by using the getPoint() function.
Source code (UnigineScript)
#include <core/scripts/utils.h>
/* ... */
// define two vec3 coordinates
vec3 p0,p1;
// get the mouse direction from camera (p0) to cursor pointer (p1)
Unigine::getPlayerMouseDirection(p0,p1);

// create an instance of the GameIntersection class
GameIntersection intersection = new GameIntersection();
 
// try to get the intersection with an obstacle.
// cylinder has radius 0.1f, intersection mask equals to 1
Obstacle obstacle = engine.game.getIntersection(p0,p1,0.1f, 1, intersection);

// check, if the intersection of mouse direction with any obstacle was occurred;
if(obstacle !=NULL)
{
  // show the coordinates of the intersection in console 
  log.message("The intersection with obstacle was here: %s\n", typeinfo(intersection.getPoint()));
}
/* ... */

Arguments

  • vec3 p0 - Start point.
  • vec3 p1 - End point.
  • float radius - Radius of the intersection cylinder.
  • int mask - Obstacle intersection mask. The obstacle is ignored if its mask does not match.
  • GameIntersection intersection - GameIntersection class instance to put the result into.

Return value

Intersected obstacle.

Obstacle engine.game.getIntersection (vec3 p0, vec3 p1, float radius, int mask, int exclude[] = [], GameIntersection intersection)

Performs intersection to find if a pathfinding Obstacle is located within the cylinder between two points. The specified obstacles will be ignored.

Notice
World space coordinates are used for this function.

Arguments

  • vec3 p0 - Start point.
  • vec3 p1 - End point.
  • float radius - Radius of the intersection cylinder.
  • int mask - Obstacle intersection mask. The obstacle is ignored if its mask does not match.
  • int exclude[] - Array with excluded obstacles. These obstacle nodes are ignored when performing intersection.
  • GameIntersection intersection - GameIntersection class instance to put the result into.

Return value

Intersected obstacle.

float engine.game.getNoise (variable position, variable radius, int frequency)

Returns a value calculated using a Perlin noise function.

Arguments

  • variable position - Point position (float or vec3).
  • variable radius - Allowed radius (float or vec3).
  • int frequency - Noise frequency.

Return value

Noise value.

Player engine.game.getPlayer ()

Returns the current player.

Return value

Current player.

variable engine.game.getRandom (variable from, variable to)

Returns a pseudo-random number within a given range, supports int, float, vec3, and vec4.

Arguments

  • variable from - Lower bound.
  • variable to - Upper bound.

Return value

Random number (type depends on arguments).

float engine.game.getScale ()

Gets a value used to scale a frame duration.

Return value

Value to scale the frame duration.

int engine.game.getSeed ()

Returns the seed for pseudo-random number generator.

Return value

Number used to initialize a pseudo-random sequence of numbers.

float engine.game.getTime ()

Returns the current time spent in the game. It is counted off starting from the world loading and does not take game pauses into account.

Return value

Time in seconds.

int engine.game.isEnabled ()

Returns a value indicating if the game is paused or not.

Return value

Positive integer if the game is not paused; otherwise, 0.

void engine.game.setData (string data)

Updates user data associated with the game. This string is written directly into a *.world file. Namely, into the data child tag of the game tag, for example:
Source code (XML)
<world version="1.21">
	<game>
		<data>User data</data>
	</game>
</world>

Arguments

  • string data - User data. Data can contain an XML formatted string.

void engine.game.setEnabled (int mode)

Pauses or resumes the current game.

Arguments

  • int mode - Positive integer to resume the game, 0 to pause it.

void engine.game.setFTime (float ftime)

Sets the maximum rendering frame duration value, that is, it restricts the frame rendering rate to a fixed one. There is no difference if the real rendering FPS is lower than the fixed frame FPS. But if the real rendering FPS is higher than the fixed frame FPS, the engine will wait until the fixed frame time is over.

To remove fixed frame duration, use -1.

Arguments

  • float ftime - Frame time in seconds. -1 removes the FPS limitation.

void engine.game.setFrame (int frame)

Sets a specified game frame.

Arguments

  • int frame - Frame number.

void engine.game.setIFps (float time)

Sets a fixed FPS that does not depend on the real FPS the hardware is capable of. That is, it forces constant frame time increments between rendered frames, used for animation/expression update etc.

This function is useful when grabbing the video reel with a fixed FPS value (for example, 25 frames per second). When this mode is activated, engine.game.getFTime() will return a fixed frame time value set with this function.

To remove fixed frame duration, use -1.

Arguments

  • float time - Frame duration in seconds (1/FPS). -1 removes the FPS limitation.

void engine.game.setPlayer (Player player)

Sets the current player.

Arguments

  • Player player - Player to set as current.

void engine.game.setScale (float factor)

Sets a value that is used to scale frame duration. It scales up or down the speed of rendering, physics and game logic. This function allows to create effects of slow/accelerated motion.

For example, if the scale equals 2, the rate of simulation of all effects (such as particles) speeds up to two times faster. As for physics, in reality it will be simulated with the same fixed physics FPS, but the number of iterations will be two times higher. (It is possible to scale the physics FPS separately via engine.physics.setScale() function).

This function scales both setIFps and setFTime.

Arguments

  • float factor - Scaling factor. The provided values is clamped within range [0;32].

void engine.game.setSeed (int seed)

Sets the seed for pseudo-random number generator.

Arguments

  • int seed - Number used to initialize a pseudo-random sequence of numbers. Non-negative value should be provided, as unsigned integer is used for it.

void engine.game.setTime (float time)

Sets a specified time for the game. The time is counted off starting from the world loading and does not take game pauses into account.

Arguments

  • float time - Time in seconds.
Last update: 2017-07-03