engine.game Functions

This class contains functions to control the game logic of the application. It provides functionality for:

• Assigning a player to the Engine Camera viewport.
• Pausing, speeding up and slowing down rendering, physics or game logic.

Usage Example

#include <core/unigine.h>

// declare a PlayerSpectator
PlayerSpectator player;

int init() {
	
	// create a new PlayerSpectator instance
	player = new PlayerSpectator();
	
	// set necessary parameters: FOV, ZNear, ZFar, view direction vector and position.
	player.setFov(90.0f);
	player.setZNear(0.1f);
	player.setZFar(10000.0f);
	player.setViewDirection(vec3(0.0f, 1.0f, 0.0f));
	player.setWorldPosition(dvec3(-1.6f, -1.7f, 1.7f));
	
	// set the player to the Game singleton instance
	engine.game.setPlayer(player);
	
	return 1;
}

int update() {

	// slow down the game logic
	if (engine.app.clearKeyState('f')) {
		engine.game.setScale(0.2f);
		log.message("Game logic speed has been decreased. Frame duration is %f seconds\n", engine.game.getFTime());
	}

	// speed up the game logic
	if (engine.app.clearKeyState('g')) {
		engine.game.setScale(2.0f);
		log.message("Game logic speed has been increased. Frame duration is %f seconds\n", engine.game.getFTime());
	}
	
	// rotate the player 45 degrees per second around Y axis 
	player.setWorldRotation(player.getWorldRotation() * quat(0.0f, 1.0f, 0.0f, 45.0f * engine.game.getIFps()));
	
	return 1;
}

Game Class

Members

void engine.game.setData(string data)

<world version="1.21">
	<game>
		<data>User data</data>
	</game>
</world>

Arguments

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

string engine.game.getData()

<world version="1.21">
	<game>
		<data>User data</data>
	</game>
</world>

Return value

void engine.game.setEnabled(int enabled)

Arguments

• int enabled - 1 to resume the game logic, 0 to pause it.

int engine.game.isEnabled()

Return value

void engine.game.setFrame(int frame)

Arguments

• int frame - Frame number.

int engine.game.getFrame()

// get the current game frame
int loading_frames = engine.game.getFrame();
// perform asynchronous nodes loading
// ...
// calculate the number of game frames required for nodes loading
loading_frames = engine.game.getFrame() - loading_frames;

Return value

void engine.game.setFTime(float ftime)

Arguments

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

float engine.game.getFTime()

Return value

void engine.game.setIFps(float ifps)

The 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.

Arguments

• float ifps - Inverse FPS value (1/FPS) in seconds.-1 removes the FPS limitation.

float engine.game.getIFps()

Node node;
// ...
// get an inverse FPS value
float ifps = engine.game.getIFps();
	
// move the node up by 0.1 unit every second instead of every frame
node.worldTranslate(Vec3(0.0f, 0.0f, 0.1f*ifps));

Return value

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

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

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.

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 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.

#include <core/scripts/utils.h>
/* ... */
// define two vec3 coordinates
vec3 p0,p1;
// get the mouse direction from camera (p0) to cursor pointer (p1)
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

Variable engine.game.getNoise(Variable pos, Variable size, int frequency)

Image image;
int size = 64;
float time = engine.game.getTime();
vec3 position;
position.z = time;
forloop(int y = 0; size) {
	position.y = y * 0.05f;
	forloop(int x = 0; size) {
		position.x = x * 0.05f;
		// generate Perlin noise for the image pixels
		float n = engine.game.getNoise(position,vec3(32.0f,32.0f,32.0f),6);
		image.set2D(x,y,n,-n,n * n);
	}
}

Arguments

• Variable pos - Position.
• Variable size - Size of the noise.
• int frequency - Noise frequency.

Return value

float engine.game.getNoise1(float pos, float size, int frequency)

Arguments

• float pos - Float position.
• float size - Size of the noise.
• int frequency - Noise frequency.

Return value

float engine.game.getNoise2(vec2 pos, vec2 size, int frequency)

Arguments

• vec2 pos - vec2 point position.
• vec2 size - vec2 size of the noise.
• int frequency - Noise frequency.

Return value

float engine.game.getNoise3(vec3 pos, vec3 size, int frequency)

Arguments

• vec3 pos - vec3 point position.
• vec3 size - vec3 size of the noise.
• int frequency - Noise frequency.

Return value

void engine.game.setPlayer(Player player)

// create a new player
PlayerDummy dummy = class_remove(new PlayerDummy());
engine.editor.addNode(dummy);
// set necessary parameters
dummy.setPosition(Vec3(-20.0f,0.0f,15.0f));
dummy.setDirection(vec3(1.0f,0.0f,-0.8f));
// set the player to the Engine Camera viewport
engine.game.setPlayer(dummy);

Arguments

• Player player - Player to set as a current one.

Player engine.game.getPlayer()

// get the current player (engine camera)
Player player = engine.game.getPlayer();
// correct player position
player.setPosition(Vec3(-92.0f,94.0f,190.0f));
// set the updated player to the Engine Camera viewport
engine.game.setPlayer(player);

Return value

int engine.game.getRandom()

Return value

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

// create a WidgetLabel
label = new WidgetLabel(gui,"Text sample");
// specify widget settings
label.setFontOutline(1);
label.setFontSize(9);

// get pseudo-random values
int x = engine.game.getRandom(0,engine.app.getWidth() - 128);
int y = engine.game.getRandom(0,engine.app.getHeight() - 128);
// use the generated values to set widget position
label.setPosition(x,y);

Arguments

• Variable from - The initial point of the range.
• Variable to - The end point of the range.

Return value

double engine.game.getRandomDouble(double from, double to)

Arguments

• double from - The initial point of the range.
• double to

Return value

float engine.game.getRandomFloat(float from, float to)

Arguments

• float from - The initial point of the range.
• float to

Return value

int engine.game.getRandomInt(int from, int to)

Arguments

• int from - The initial point of the range.
• int to - The end point of the range.

Return value

void engine.game.setScale(float scale)

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 can be used 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 values set by both the setIFps() and setFTime().

Arguments

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

float engine.game.getScale()

Return value

void engine.game.setSeed(int seed)

Arguments

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

int engine.game.getSeed()

Return value

void engine.game.setTime(float time)

Arguments

• float time - Time in seconds.

float engine.game.getTime()

Return value