# Unigine::Game Class

Header: | #include <UnigineGame.h> |

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*#*

The example below creates a PlayerSpectator and sets it as the active Engine Camera. The player is rotated around Y axis with the specified speed, which is set via *setScale()*:

- Pressing f slows down the game logic, so player's rotation slows down too.
- Pressing g speeds up the game logic and, therefore, player's rotation.

```
#include "AppWorldLogic.h"
#include <UniginePlayers.h>
#include <UnigineGame.h>
#include <UnigineApp.h>
#include <UnigineControls.h>
using namespace Unigine;
using namespace Math;
// declare a PlayerSpectator pointer
PlayerSpectatorPtr player;
int AppWorldLogic::init() {
// create a new PlayerSpectator instance
player = PlayerSpectator::create();
// 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
Game::setPlayer(player);
player->release();
return 1;
}
int AppWorldLogic::update() {
// slow down the game logic
if (App::clearKeyState('f')) {
Game::setScale(0.2f);
Log::message("Game logic speed has been decreased. Frame duration is %f seconds\n", Game::getFTime());
}
// speed up the game logic
if (App::clearKeyState('g')) {
Game::setScale(2.0f);
Log::message("Game logic speed has been increased. Frame duration is %f seconds\n", 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 * Game::getIFps()));
return 1;
}
int AppWorldLogic::shutdown() {
// clear the pointer
player.clear();
return 1;
}
```

#### See Also*#*

- The article on the
*GameIntersection*class as a usage example of game intersections - A set of UnigineScript API samples located in the <UnigineSDK>/data/samples/systems/ folder:
- noise_00
- random_00

## Game Class

### Members

## void setData
(
const char * data
)
*#*

Sets user data associated with the game logic. This string is written directly into a *.world file. Namely, into the *data*child tag of the

*game*tag, for example:

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

### Arguments

*const char ****data**- User data. Data can contain an XML formatted string.

## const char * getData
(
)
const*#*

Returns user data associated with the game logic. This string is written directly into a *.world file. Namely, into the *data*child tag of the

*game*tag, for example:

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

### Return value

User data. Data can contain an XML formatted string.## void setEnabled
(
bool enabled
)
*#*

Pauses or resumes the game logic.### Arguments

*bool***enabled**-**1**to resume the game logic,**0**to pause it.

## bool isEnabled
(
)
const*#*

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

1 if the game logic is not paused; otherwise, 0.## void setFrame
(
int frame
)
*#*

Sets the game frame with the given number as the current one.### Arguments

*int***frame**- Frame number.

## int getFrame
(
)
const*#*

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

### Return value

Frame number.## void setIFps
(
float ifps
)
*#*

Sets the scaled inverse FPS value (the time in seconds it took to complete the last frame). This function 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. To remove the FPS limitation, use -1.
The function is useful when grabbing the video reel with a fixed FPS value (for example, 25 frames per second).

### Arguments

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

## float getIFps
(
)
const*#*

Returns the scaled inverse FPS value (the time in seconds it took to complete the last frame). This value does not depend on the real FPS the hardware is capable of. -1 means no Inverse FPS value is set.
```
NodePtr node;
// ...
// get an inverse FPS value
float ifps = Game::getIFps();
// move the node up by 0.1 unit every second instead of every frame
node->worldTranslate(Math::Vec3(0.0f, 0.0f, 0.1f*ifps));
```

### Return value

Scaled inverse FPS value (1/FPS) in seconds. If the game is paused,**0**is returned.

## Ptr<Obstacle> getIntersection
(
Vec3 p0, Vec3 p1, float radius, int mask, const Vector<Ptr<Node>> & exclude,
Math::Vec3 * intersection
)
*#*

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

### 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.*const Vector<Ptr<Node>> &***exclude**- Array with excluded obstacles. These obstacle nodes are ignored when performing intersection.*Math::Vec3 ****intersection**- Intersection point.

### Return value

Intersected obstacle.## Ptr<Obstacle> getIntersection
(
Vec3 p0, Vec3 p1, float radius, int mask, const Ptr<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 we specify a cylinder from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1) with the specified radius. The executing sequence is the following:

- Define and initialize two points (p0 and p1) by using the
*Player::getDirectionFromScreen()*. - Create an instance of the GameIntersection class to get the intersection point coordinates.
- Check, if there is an intersection with an obstacle. The
*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.

```
// AppWorldLogic.cpp
/* ... */
// initialize points of the mouse direction
Vec3 p0, p1;
// get the current player (camera)
PlayerPtr player = Game::getPlayer();
if (player.get() == NULL)
return 0;
// get width and height of the current application window
int width = App::getWidth();
int height = App::getHeight();
// get the current X and Y coordinates of the mouse pointer
int mouse_x = App::getMouseX();
int mouse_y = App::getMouseY();
// get the mouse direction from the player's position (p0) to the mouse cursor pointer (p1)
player->getDirectionFromScreen(p0,p1,mouse_x, mouse_y, width, height);
// create an instance of the GameIntersection class
GameIntersectionPtr intersection = GameIntersection::create();
// try to get the intersection with an obstacle
// cylinder has radius 1.5f, intersection mask equals to 1
ObstaclePtr obstacle = Game::getIntersection(p0, p1, 1.5f, 1, intersection);
// check, if the intersection of mouse direction with any obstacle was occurred;
if (obstacle)
{
// show the coordinates of the intersection in console
Log::message("The intersection with the obstacle was here: (%f %f %f)\n", intersection->getPoint().x, intersection->getPoint().y, intersection->getPoint().z);
}
/* ... */
```

### 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.*const Ptr<GameIntersection> &***intersection**- GameIntersection class instance to put the result into.

### Return value

Intersected obstacle.## float getNoise1
(
float pos, float size, int frequency
)
const*#*

Returns a noise value calculated using a Perlin noise function.### Arguments

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

### Return value

Noise value.## float getNoise2
(
const
Math::vec2 & pos, const
Math::vec2 & size, int frequency
)
const*#*

Returns a 2D noise value calculated using a Perlin noise function.### Arguments

*const Math::vec2 &***pos**- vec2 point position.*const Math::vec2 &***size**- vec2 size of the noise.*int***frequency**- Noise frequency.

### Return value

2D noise value.## float getNoise3
(
const
Math::vec3 & pos, const
Math::vec3 & size, int frequency
)
const*#*

Returns a 3D noise value calculated using a Perlin noise function.### Arguments

*const Math::vec3 &***pos**- vec3 point position.*const Math::vec3 &***size**- vec3 size of the noise.*int***frequency**- Noise frequency.

### Return value

3D noise value.## void setPlayer
(
const Ptr<Player> & player
)
*#*

Assigns a new player to the *Engine Camera*viewport.

```
// create a new player
PlayerDummyPtr player = PlayerDummy::create();
// set necessary parameters
player->setFov(60.0f);
player->setWorldPosition(Math::dvec3(-1.0f, -1.0f, 1.0f));
// set the player to the Game singleton instance
Game::setPlayer(player);
```

### Arguments

## Ptr<Player> getPlayer
(
)
const*#*

Returns the current player assigned to the *Engine Camera*viewport.

```
Vec3 p0, p1;
// get the current player (camera)
PlayerPtr player = Game::getPlayer();
if (player.get() == NULL)
return 0;
// get the mouse direction from the player's position (p0) to the mouse cursor pointer (p1)
player->getDirectionFromScreen(p0, p1);
```

### Return value

Current player.## unsigned int getRandom
(
)
const*#*

Returns a pseudo-random unsigned integer number.### Return value

Random unsigned integer number.## double getRandomDouble
(
double from, double to
)
*#*

Returns a pseudo-random double number within a given range (end-point not included).### Arguments

*double***from**- The initial point of the range.*double***to**- The end point of the range.

### Return value

Random double integer number.## float getRandomFloat
(
float from, float to
)
*#*

Returns a pseudo-random float number within a given range (end-point not included).### Arguments

*float***from**- The initial point of the range.*float***to**- The end point of the range.

### Return value

Random float number.## int getRandomInt
(
int from, int to
)
*#*

Returns a pseudo-random integer number within a given range (end-point not included).### Arguments

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

### Return value

Random integer number.## void 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 the value set by the *setIFps()*.

### Arguments

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

## float getScale
(
)
const*#*

Returns a value used to scale the frame duration.### Return value

Value to scale the frame duration.## void setSeed
(
int seed
)
*#*

Sets the seed for pseudo-random number generator.### Arguments

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

## int getSeed
(
)
const*#*

Returns the seed for pseudo-random number generator.### Return value

Number used to initialize a pseudo-random sequence of numbers.## void setTime
(
float time
)
*#*

Sets the time value 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.