Graal Bible - User contributions [en]

Bomberman MiniGame

2021-11-22T14:17:02Z

JimmyAkl:

Welcome to the Bomberman Minigame Tutorial!

= BomberMan =

==== Intro ====
BomberMan is a multiplayer game (usually 4 players). Each player can drop bombs that, upon explosion, destroy the grey pillars making a path to other players. The objective of the game is to eliminate other players with the exploding bombs. Power ups are also sometimes dropped when pillars are destroyed (increase of speed, explosion power and number of bombs allowed to place at a time).
[[File:Bomberman cover.png|none|thumb|675x675px]]
Assets Bundle : <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=bombermanMinigame.unitypackage</nowiki>

'''bombermanprefabs'''

[[File:Bomberman prefabs.png|frameless]]

and '''bombermanlevel1'''

[[File:Bomberman level prefab.png|frameless]]

Since this game is meant to be multiplayer, we will be placing the GameObjects in NPCs for them to be visible to all the players and triggerring the server every time we want to place them. (more info on that here: [[Placing GameObjects in NPC]])

First, we have the weapon that launches the game and places the NPCs (''found under '''weapon: 3D/Samples/BomberMan/Game''''')

We've implemented a graalscript UI (which is not covered in this section, considering you know graalscript) that allows us to launch the game;
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
//temp.pnpc.DropBomb(explvl);
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}

//#CLIENTSIDE
function onCreated() {
echo(this.name @ " OnCreated");
}

public function Load() {
level.explosionpower = 3; //for powerups with explosion
level.numberofbombs = 2; //number of bombs allowed to place at a time
level.speed = 7; //player default speed

echo(this.name @ " LOAD");
Object::destroy(this.bomberManParentNode);
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
new GuiButtonCtrl("bomberman_Quit") {
profile = GuiBlueButtonProfile;
x = 600;
y = 200;
width = 150;
height = 30;
text = "bombermanQuit";
}

temp.warpLevel = "only_ground.nw";
temp.warpX = 4.65;
temp.warpY = 21.33;
temp.warpZ = 0.7;
WARPMANAGER.Warp(temp.warpX, temp.warpY ,temp.warpZ ,temp.warpLevel);
sleep(0.5);
start();
}

function bomberman_Quit.onAction() {
BomberManQuit();
}

public function BomberManQuit() {
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
PLAYERMOVEMENT.UnFreeze();
PLAYERMOVEMENT.canJump = true;
this.GAMEON = false;
}

function start() {
PLAYERMOVEMENT.canJump = false;
this.GAMEON = true;
triggerserver("gui", this.name, "level", -60 , 14);
}

function onKeyPressed(keycode, keychar) {
if (this.GAMEON == true) {
if (keycode == "32, ,57") {
DropBomb();
}
}
}

function DropBomb() {
this.hit = RaycastHit::create();
done = Physics::Raycast(player.gameobject.transform.position, Vector3::Down, this.hit, 100);
//sleep(0.05);
triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}

the '''''Load()''''' function is called when the minigame is launched (Devtools -> Minigames -> BomberMan).

'''level.explosionpower = 3;''' is how much tiles the explosion is going to cover. (at the beginning it's 3)

'''level.numberofbombs = 2;''' is the number of bombs a player is allowed to place at a time. (at the beginning it's 2)

In the function '''''start()''''', we trigger the server with the command "'''level'''" to load the bomberman map by placing an NPC and joining it with the class "'''3d_samples_bomberman_level'''".

Once we start the game, the player is not allowed to Jump: '''PLAYERMOVEMENT.canJump = false;'''

And pressing space will be used to drop a bomb, '''''function onKeyPressed()''''' checks if space is pressed and calls '''''DropBomb()'''.''

==== New: RayCast: ====
Think of RayCast as '''''triggeraction()''''' that triggers NPCs at a given (x,y). Similarly, '''''RayCast''''' casts a ray given a position (origin), a direction and a length, detecting colliders.
{| class="wikitable"
!Raycast(Vector3 origin, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);
|}
'''Returns:''' Boolean indicating if the RayCast hit a Collider.

''(More info here: https://docs.unity3d.com/ScriptReference/Physics.Raycast.html<nowiki/>)''

Here, since the bomberman level is a grid and the floor is made of squares. We want the player to drop the bomb exactly in one square and not in between two. Therefore, when space is pressed, we RayCast with the PlayerGameObject as '''origin''', with a Vector3::Down '''direction''', '''''this.hit''''' as the '''output''' and 100 for '''length'''. The other parameters are kept as default.

This will return the collider of the GameObject underneath the player, which is one square tile.

We extract the tile's position from '''''this.hit''''':
{| class="wikitable"
!this.hit.transform.gameobject.transform.position.x / y
|}
And we trigger the server, with the command "bomb" and the coordinates, to place a bomb NPC;
{| class="wikitable"
!triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
|}
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}
Now, on to the classes!

'''"3d_samples_bomberman_level" Class:'''
function onCreated() {
//Set a 10 minute timer to automatically destroy the levelprefab
scheduleEvent(120, "DestLvl");
}
//Destroy if the server restarts

function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "dest") onDestLvl();
}

function onDestLvl() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
(@"3D/Dev/AssetManager").loadAssetBundle("bombermanlevel1");
}

function onAssetBundleDownloaded(bundlename){
if (bundlename == "bombermanlevel1") {
player.chat = "bombermanlevel loaded";
temp.prefab = GameObject::fromassetbundle("bombermanlevel1", "assets/bombermantest/big level 2.prefab");
this.bomberlevel = Object::Instantiate(Type::GameObject, temp.prefab, this.gameobject.transform, false);
this.bomberlevel.transform.parent = this.gameobject.transform;
this.bomberlevel.transform.localposition = v3(-15,0,0);
this.bomberlevel.transform.localscale = v3(1,1,1);
}
}

function onPlayerChats() {
if (player.chat == "dest") Object::Destroy(this.gameobject);
}
Here we place the level GameObject in an NPC ([[Placing GameObjects in NPC]]) and we only load and instantiate the level the usual way ([[Uploading and Loading AssetBundles]]).

'''"3d_samples_bomberman_bomb" Class:'''
function onCreated() {
//echo("merlin_testbomb");
scheduleEvent(3600, "RemoveBomb");
}

//Destroy if the server restarts
function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "/destroy") {
onRemoveBomb();
}
}

function onRemoveBomb() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
this.dropped = false;
this.powerup = randomstring({"bomb", "explosion", "speed"});

DropBomb();
}

function DropBomb() {
if (level.numberofbombs == 0) return;
--level.numberofbombs;

(@"3D/Dev/AssetManager").loadAssetBundle("bombermanprefabs");
(@"3D/Dev/AssetManager").loadAssetBundle("staffstick");
this.speedprefab = GameObject::fromassetbundle("staffstick","assets/johntest/staffstick_era.prefab");
this.explosionprefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/explosion.prefab");
this.prefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/bomb.prefab");
this.bomb = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localeulerangles = v3(0, 0, 0);
this.bomb.transform.localposition = v3(0, 0.5, 0);

scheduleEvent(3, "Explode");
}

function onExplode() {
echo("onexplode");

echo ("prefab type=" @ this.explosionprefab.objecttype());
this.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
echo ("explosion type=" @ this.explosion.objecttype());
this.explosion.transform.parent = this.gameobject.transform;
this.explosion.transform.localposition = v3(0, 0, 0);
this.explosion.transform.localscale = v3(1,1,1);

Object::Destroy(this.bomb, .3f);

this.exploded = true;

CreateExplosion(Vector3::forward);
CreateExplosion(Vector3::right);
CreateExplosion(Vector3::back);
CreateExplosion(Vector3::left);

++level.numberofbombs;
}

function CreateExplosion(direction) {
for (temp.i = 1; temp.i < level.explosionpower; temp.i++) {
this.hit = RaycastHit::create();
done = Physics::Raycast(this.bomb.transform.position.Add(v3(0,0.5,0)), direction, this.hit, temp.i);

if (!done || this.hit.transform.gameobject.name.starts("assets/bomberman/prefabs/explosion.prefab") || this.hit.transform.gameobject.name.starts("TPlayer")){
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.localposition = v3(0,0,0).Add(direction.Mult(temp.i));
Object::Destroy(temp.explosion, 0.7);
}
if (this.hit.transform.gameobject.name.starts("E_Bomber_Pilar_01_")|| this.hit.transform.gameobject.transform.parent.gameobject.name.starts("E_Bomber_Pilar_01_")) {
if (!this.dropped) {
if (rand(0,1) < 0.2) {
this.dropped = true;
//drop power up
droppowerup(this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}
}
Object::Destroy(this.hit.transform.gameobject.transform.parent.gameobject);
Object::Destroy(this.hit.transform.gameobject);
Object::Destroy(temp.explosion, 0.7);
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.position = this.hit.transform.position;
}
}
}

function droppowerup(x,z) {
if (this.powerup == "bomb") {
this.powerupGO = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
}
if (this.powerup == "explosion") {
this.powerupGO = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
}
if (this.powerup == "speed") {
this.powerupGO = Object::instantiate(Type::GameObject, this.speedprefab, this.gameobject.transform, false);
}
this.powerupGO.transform.position = v3(x, 0.5, z);
this.powerupGO.transform.scale = v3(0.5,0.5,0.5);

sphereCollider = this.powerupGO.AddComponent(Type::SphereCollider);
sphereCollider.size = v3(1, 10, 1);
}

public function onActionGrab() {
player.chat = this.powerup;
Object::Destroy(this.gameobject);
if (this.powerup == "bomb") {
++level.numberofbombs;
}
if (this.powerup == "explosion") {
++level.explosionpower;
}
if (this.powerup == "speed") {
PLAYERMOVEMENT.setSpeed(7);
}
}
Again, we are loading and instantiating the prefabs in an NPC.

In '''''function onCreated()''''':

* '''''this.dropped''''' variable is used to allow every bomb to drop only one powerup.
* '''''this.powerup''''' variable is the name of the powerup, chosen randomly each time a bomb is dropped.

'''''DropBomb()''''' is responsible for loading, instantiating and placing the bomb. The player can drop 2 bombs at a time at the start of the game. Therefore, we begin by checking if the player can drop bombs. We decrease the variable '''''level.numberofbombs''''' when a bomb is dropped and decrease it when the bomb explodes.

After positioning the bomb, we schedule event to create the explosion after 3 seconds of placing the bomb;
{| class="wikitable"
!scheduleEvent(3, "Explode");
|}
'''''onExplode()''''' function instantiates an explosion under the bomb;
{| class="wikitable"
!this.explosion.transform.localposition = v3(0, 0, 0);
|}
and calls '''''CreateExplosion(direction);''''' in all the four directions (forward, right, left, back) to instantiate explosions in a cross shape around the bomb.

'''''CreateExplosion(direction)''''' casts a Ray in all the four directions with the given length ('''level.explosionpower'''; the number of tiles it covers) and the bomb as the origin.
{| class="wikitable"
!this.bomb.transform.position.Add(v3(0,0.5,0));
|}we add a '''''Vector3 (0, 0.5, 0)''''' to increase the Y of the '''RayCast''' for it to hit the grey pillars and not the ground.

The two conditional blocks after are used to check if the collider hit by the raycast is a pillar or not.

if it's a Grey Pillar, we destroy it. If not then it's empty space and we instantiate an explosion.

When a Pillar is destroyed, there's a 20% chance it will drop a powerup, by calling the function '''''droppowerup(x,z)''''' with (x,z) the coordinates of the Pillar.

'''''droppowerup(x,z)''''' will check '''''this.powerup''''' and create and place the appropriate GameObject. It also adds a collider Component to be triggered onActionGrab;

==== New: onActionGrab for NPCs: ====
For this to work, the GameObject is required to have a collider.

And '''''public function onActionGrab()''''' needs to be implemented.

Here, we destroy the powerup GameObject and give the player the powerup.

(''weapon: '''3D/Player/Grab''''' for more info)

Plane MiniGame

2021-11-22T14:15:06Z

JimmyAkl:

This minigame is similar to the Car driving minigame. However, we move a plane through obstacles.

'''AssetBundles:''' <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=cars_planes_minigame.unitypackage</nowiki>

using the bundle explorer (F10):

'''minigameplane:'''

[[File:Plane.png|frameless]]

[[File:Obstacles.png|frameless]]

'''env:'''

[[File:Environment.png|frameless]]

Weapon: '''''3D/Samples/Planeminigame'''''
findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE

function onCreated() {
this.keepAlive = true;//SetTimer(9999);
}

function onPlayerChats() {
if (player.chat == "plane") start();
}

public function start() {
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
new GuiWindowCtrl("PlaneMinigame") {
profile = GuiBlueWindowProfile;
x = 120;
y = 0;
width = 670;
height = 340;
text = "Plane Minigame";

new GuiButtonCtrl("Plane") {
profile = GuiBlueButtonProfile;
x = 150;
y = 90;
width = 150;
height = 30;
text = "Spawnplane";
}
new GuiButtonCtrl("Exit") {
profile = GuiBlueButtonProfile;
x = 150;
y = 120;
width = 150;
height = 30;
text = "Exit";
}
}
}

function Plane.onAction() {
exit();
PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANGER.freecam = true;
this.empty = GameObject::Create("empty");
Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
(@"3D/Dev/AssetManager").loadAssetBundle("minigameplane");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigameplane") {
this.planeprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/small_plane02.prefab");
this.plane = Object::Instantiate(Type::GameObject, this.planeprefab);
this.plane.transform.position = v3(player.x, player.z, player.y);
this.plane.transform.localscale = v3(0.3, 0.3, 0.3);
this.plane.transform.parent = this.empty.transform;

this.RB = this.plane.AddComponent(Type::RigidBody);
this.RB.useGravity = false;

boxCollider = this.plane.AddComponent(Type::BoxCollider);
boxCollider.size = v3(4,4,4);

Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");

this.obstacleprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/obstacles 1.prefab");
this.obstacle = Object::Instantiate(Type::GameObject, this.obstacleprefab);
this.obstacle.transform.position = v3(player.x, player.z + 10, player.y + 20);
this.obstacle.transform.localscale = v3(0.3, 0.3, 0.3);
this.obstacle.transform.parent = this.empty.transform;
}
if (bundlename == "env") {
this.envprefab = GameObject::fromassetbundle("env", "assets/jimmyenv2/environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.envprefab);
this.env.transform.position = v3(player.x, player.z + 1.5, player.y);
this.env.transform.parent = this.empty.transform;
}
}

function onUpdate() {
temp.campos = this.plane.transform.position.Add(v3(20,0,0));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

this.verticalInput = Input::GetAxis("Vertical");
this.horizontalInput = Input::GetAxis("Horizontal");

this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));

this.plane.transform.rotate(Vector3::Right.Mult(700 * Time::deltaTime * this.verticalInput));

this.plane.transform.rotate(Vector3::Forward.Mult(700 * Time::deltaTime * this.horizontalInput * -1));

this.propellor = this.plane.transform.Find("Propellor");
this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));
}

public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

function Exit.onAction() {
exit();
}

function exit() {
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.empty);
Input::ResetInputAxes();
}

The function '''''start()''''' creates a UI with two buttons (Spawn Plane and Exit) allowing us to start and end the game.

'''Plane.onAction()''' ''(when the Spawn button is pressed) :''

Calls the '''''exit()''''' function first to destroy GameObjects instantiated before, freezes the player using '''PLAYERMOVEMENT.Freeze();''' ,frees the camera with '''Quattro3D::PlayerCamera::Instance.FreeCam = true;''' and loads all the assets we'll need to use.

In function '''''onAssetBundleDownloaded(bundlename)''''' we catch all the loaded assetbundles, we instantiate the plane, obstacles and environment. And we position them, modify their scales, add components to them and make them a child of an empty GameObject.
{| class="wikitable"
!this.empty = GameObject::Create("empty");
|}
{| class="wikitable"
!this.obstacle.transform.parent = this.empty.transform;
|}
This will help delete all the GameObjects upon deleting the empty GameObject. ('''Object::Destroy(this.empty);''')

Now, the '''''onUpdate()''''' function checks for updates on every frame. '''''SetTimer(9999)''''' needs to be added for it to work.

This function will be responsible for moving the plane, moving the camera following the plane and turning the propeller of the plane.

First for the Camera, we want it to be looking side ways at the plane. We take the plane's position and add to the X axis:
{| class="wikitable"
!temp.campos = this.plane.transform.position.Add(v3(20,0,0));
|}
then we change the camera position to '''''temp.campos;'''''
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;
|}
We'll also need to change the rotation of the camera since it's initially facing forward and we want it to face the plane;
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
|}
Now, for the movement of the plane. It will be moving forward at a constant speed; '''''this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));'''''

And the '''''Input::GetAxis()''''' will help us move it up/down and sideways.

We also find the propellor of the plane and move it at a constant rotation speed;

'''''this.propellor = this.plane.transform.Find("Propellor");'''''

'''''this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));'''''

Finally, the function '''''exit()''''' switches back to the default camera: '''''findweapon("3D/Dev/ToolBar/Camera").cam1();'''''

unfreezes the Player, destroys the GameObjects and resets the Input Axes using: '''''Input::ResetInputAxes();'''''
[[File:Planeminigame gameplay.png|center|thumb|1108x1108px]]You can also add collision detection to the plane to turn it into an actual game.
Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");
and implement the function:
public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

Driving MiniGame

2021-11-22T14:14:32Z

JimmyAkl:

Welcome to the Driving MiniGame tutorial.

= Intro =

==== DrivingMiniGame ====
This is a simple and easy car driving example. In the assetbundle, there's an environment that we load and instantiate and multiple cars that we can spawn. This game is not focused on the actual driving experience itself, but more on introducing new Unity functionalities.

'''Asset Bundles:''' <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=cars_planes_minigame.unitypackage</nowiki>

using the bundle explorer (F10):

'''minigame2:'''

[[File:Minigame2.png|frameless]]

'''env:'''

[[File:Minigame2 env.png|frameless]]

Weapon: '''''3D/Samples/Drivingminigame'''''
findplayer("GraalID").addweapon(this.name);
this.join("3d_merlin_camera");

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "dest") dest();
if (player.chat == "drive") drive();
}

function drive() {
destLevelName = "only_ground.nw";
x = 19;
y = 10;
z = 0.7;//0.7;
WARPMANAGER.Warp(x, y ,z ,destLevelName);

sleep(1);

new GuiWindowCtrl("MyGUI_Minigame_Window1") {
profile = GuiBlueWindowProfile;
style = $pref::Video::defaultguistyle;
clientrelative = true;
clientextent = "320,240";

canmove = true;
canresize = true;
closequery = false;
destroyonhide = false;
text = "Window 1";
x = 490;
y = 242;

new GuiButtonCtrl("MyGUI_Minigame_Button1") {
profile = GuiBlueButtonProfile;
text = "Car";
width = 80;
x = 77;
y = 31;
}
new GuiButtonCtrl("MyGUI_Minigame_Button2") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Bus";
width = 80;
x = 77;
y = 69;
}
new GuiButtonCtrl("MyGUI_Minigame_Button3") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Quit";
width = 80;
x = 78;
y = 109;
}
new GuiTextCtrl("MyGUI_Minigame_Text1") {
profile = GuiBlueTextProfile;
height = 20;
text = "Select Type:";
width = 71;
x = 11;
y = 5;
}
}
}

function MyGUI_Minigame_Button1.onAction() {
// Button "Car" has been pressed
(@"3D/Dev/AssetManager").loadAssetBundle("minigame2");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
this.vehicle = "car";
}

function MyGUI_Minigame_Button2.onAction() {
// Button "Bus" has been pressed
(@"3D/Dev/AssetManager").loadAssetBundle("minigame2");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
this.vehicle = "bus";
}

function MyGUI_Minigame_Button3.onAction() {
dest();
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "env") {
this.env = GameObject::fromassetbundle("env", "assets/jimmyenv2/Environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.env);
this.env.transform.position = v3(player.x, player.z, player.y);
}
if (bundlename == "minigame2") {
if (this.vehicle == "bus") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Bus_Blue_Z.prefab");
}

if (this.vehicle == "car") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Car_Blue_Z.prefab");
}

this.vh = Object::Instantiate(Type::GameObject, this.vh);
this.vh.transform.position = v3(player.x - 2, player.z, player.y - 5);
this.vh.AddComponent(Type::RigidBody);

PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANAGER.freecam = true;
handleMovement();
}
}

function handleMovement() {
this.on = true;
SetTimer(0.05);
this.speed = 20;
this.rotation = 400;
}

function onFixedUpdate() {
this.vInput = Input::GetAxis("Vertical");
this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

this.hInput = Input::GetAxis("Horizontal");
this.vh.transform.Rotate(Vector3::up.Mult(Time::deltaTime * this.rotation * this.hInput * this.vInput));
}

function onTimeOut() {
if(this.on) {
temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

//this.vInput = Input::GetAxis("Vertical");

//this.hInput = Input::GetAxis("Horizontal");
//if (this.vInput < 0) this.hInput = - Input::GetAxis("Horizontal");

//this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

SetTimer(0.05);
}
}

function dest() {
this.on = false;
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.vh);
Object::Destroy(this.env);
}

Here we create a UI for the player to choose what vehicle to choose, and we load and instantiate the prefab based on the choice.

==== New: Camera ====
The Camera is the point of view. Here we want the Camera to follow the car while driving and not the player.

In '''''function onAssetBundleDownloaded(bundlename)''''' We use:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.FreeCam = true;
|}
To free the camera. This will free it from following the player GameObject.

Then in '''''function onTimeOut()''''' we want the camera position to be updated with the vehicle's position.

'''''temp.campos''''' is the variable we store the camera's position in. We want it to be behind and above the vehicle for a good view. This is why we get the vehicle's position and add a Vector3 to it:
{| class="wikitable"
!temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
|}
now:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position
|}
allows us to the get the Camera GameObject and to access its transform component and change its position.

We have implemented default cameras found in Weapon: '''''3D/Dev/ToolBar/Camera'''''

We access them through the Weapon "'''''3D/Dev/ToolBar/Camera'''''" using:
{| class="wikitable"
!''findweapon("3D/Dev/ToolBar/Camera").cam1();''
|}and we call the function '''''cam1();''''' in '''''function dest()''''' to go back to the default cam.

==== New: Unity Input ====
{| class="wikitable"
!Input::GetAxis("Vertical");
|}
"Vertical" / "Horizontal"

It checks the arrows pressed and gives a value in the range of (-1 to 1) -1 indicating "down", 1 "up" and 0 "neutral".

We use it here to translate and rotate the vehicle.

Turret MiniGame

2021-11-22T14:13:38Z

JimmyAkl:

Welcome to the Turret Minigame!

In this Tutorial, we will build a turret that rotates and shoots targets around it.

Asset Bundles are available here : <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=Turretminigame.unitypackage</nowiki>

==== TurretMiniGame GameObjects ====
All the prefabs are under the asset bundle: '''minigame''' (you can view them in the bundle explorer "F10")

Turret that shoots the projectiles:

[[File:Turret.png|frameless|407x407px]]

Robot that will serve as a target:

[[File:Robot Obstacle Minigame.png|frameless|407x407px]]

Cubes Instantiated in different position also for targets:

[[File:Turret Minigame targets.png|frameless|405x405px]]

findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "start") {
destroy();
start();
}
if (player.chat == "dest") destroy();
}
The way I start the minigame is '''onPlayerChats'''; when the player says "start". We'll also see how to '''destroy the GameObjects''' when the player says "dest".
function start() {
this.start = true;
//PLAYERMOVEMENT.Freeze();

//for turret control
this.rotateangle = 0; //Rotation angle of the turret
this.rotateangleB = 270; //Rotation angle of the barrel
this.speed = 15;

this.currentX = player.x;
this.currentY = player.y;
this.currentZ = player.z;
echo ("TurretMiniGame warp from=" @ this.currentLevel @ " x=" @ this.currentX @ " y=" @ this.currentY @ " z=" @ this.currentZ);
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
sleep(1.5);

(@"3D/Dev/AssetManager").loadAssetBundle("minigame"); //loading the assetbundle
}
'''''this.start = true;''''' will be used to indicate that the game has started.

==== New: Using PLAYERMOVEMENT and WARPMANAGER ====
'''PLAYERMOVEMENT.Freeze()''' is a method that freezes the player (weapon: '''3D/Player/Core/Movement)'''

'''WARPMANAGER.Warp(x,y,z,level)''' (weapon: '''3D/Player/Core/Warp/Manager''')

Having uploaded the Asset bundle called "'''minigame'''" that contains the prefabs to the server, I start off by loading them, creating the prefabs, instantiating them and giving them a position in the '''start function''' ([[Uploading and Loading AssetBundles|Uploading and Loading AssetBundles]] for info on how to upload assets).
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigame") {
SetTimer(9999);
this.empty = GameObject::Create("empty"); // for parenting and deleting

this.turret = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/turret.prefab");
this.robot1 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.robot2 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.wreckedrobotprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot wrecked.prefab");
this.projectileprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/projectile.prefab");
this.explosion = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/explosion.prefab");

this.turret = Object::Instantiate(Type::GameObject, this.turret);
this.robot1 = Object::Instantiate(Type::GameObject, this.robot1);
this.robot2 = Object::Instantiate(Type::GameObject, this.robot2);

this.turret.transform.position = v3(player.x, player.z, player.y);
this.robot1.transform.position = v3(player.x - 5, player.z - 1, player.y + 10);
this.robot2.transform.position = v3(player.x + 5, player.z - 1, player.y + 10);

this.turret.transform.localscale = v3(1,1,1);
this.robot1.transform.localscale = v3(1,1,1);
this.robot2.transform.localscale = v3(1,1,1);

loadCubes();

player.charactercontroller.enabled = false;
player.gameobject.transform.position = v3(player.x, player.z+5, player.y);

this.launcher = GameObject::Find("Launcher");
this.barrel = GameObject::Find("Barrel");
}
}

function loadCubes() {
temp.width = 10;
temp.height = 4;

for (temp.y = 0; temp.y < temp.height; ++temp.y) {
for (temp.x = 0; temp.x < temp.width; ++temp.x) {
temp.block = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.block.Name = "myblock";
temp.block.transform.parent = this.empty.transform; // for deleting
temp.block.transform.position = v3(player.x - 5 + temp.x, player.z + temp.y, player.y + 15);
temp.block.AddComponent(Type::RigidBody);
temp.block.layer = this.projectile.layer;
}
}

temp.nbofobjects = 20;
temp.radius = 7f;

for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.parent = this.empty.transform;
this.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
this.cube.AddComponent(Type::RigidBody);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
this.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
In the '''''loadCubes()''''' function we instantiate primitive type cubes and position them to build a wall and a circular formation around the turret.

==== New: Moving the Player GameObject ====
The player is a GameObject, and its accessed by:
{| class="wikitable"
!player.gameobject
|}
Before changing the player's transform, the '''''player.charactercontroller''''' must be disabled:
{| class="wikitable"
!player.charactercontroller.enabled = false;
|}
Then we can change the position accessing the transform component of the GameObject:
{| class="wikitable"
!player.gameobject.transform.position = Vector3::Create(player.x, player.z+5, player.y);
|}

==== New: Parenting ====
In Unity, parenting is when a GameObject becomes a parent of another GameObject. The child GameObject will perform all it's transform changes in respect to the parent GameObject and not the Camera. Additionally, deleting the parent GameObject will delete all its children.

We use it for the latter. We create the '''Empty GameObject''', which will serve as a parent for the Cubes ''(children)'' in order to delete them all, since we don't have a reference to each and every cube.

==== New: Finding GameObjects by Name ====
{| class="wikitable"
!GameObject::Find("name")
|}
We use it to find the barrel that we'll move up and down and the launcher that shoots the projectiles.

Now to move the Turret;
function onKeyPressed(keycode) {
if (keycode == "90") { // Z
this.rotateangle -= 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "67") { // C
this.rotateangle += 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "87") { // W
this.rotateangleB = this.rotateangleB < 300? this.rotateangleB + 4: 300;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "83") { // S
this.rotateangleB = this.rotateangleB > 258? this.rotateangleB - 4: 258;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "32, ,57") { // Space
if (this.start) {
shoot();
}
}
}
We rotate the barrel around the X axis for it to go up and down;
{| class="wikitable"
!Quaternion::euler(this.rotateangleB, 0, 0);
|}
And rotate the turret around the Y axis (Vertical axis);
{| class="wikitable"
!Quaternion::euler(0, this.rotateangle, 0);
|}
this.rotateangle for both cases starts at the initial rotation of the GameObjects and is incremented/decremented based on the direction of the rotation.

In the last conditional block, if space is pressed and if the Game is on ('''''this.start == true'''''), the projectile is shot. Here's how it's done;
function shoot() {
SetTimer(9999);
this.projectile = Object::Instantiate(Type::GameObject, this.projectileprefab);
this.projectile.transform.parent = this.empty.transform;
this.projectile.transform.position = this.launcher.transform.position;
this.projectile.transform.scale = v3(1,1,1);

temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);

Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
}
The projectile is initialized and positioned on the launcher.

We'll need to use physics to shoot the projectile, this is why we get the RigidBody component of the GameObject;
{| class="wikitable"
!temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
|}
(if the GameObject doesn't have a RigidBody by default, you'll need to add it using: '''''gameobject.AddComponent(Type::RigidBody);''''')

We then add velocity (which is a vector that represents speed in a certain direction). The direction is the Launcher's forward direction, it is multiplied by the desired speed;
{| class="wikitable"
!temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);
|}
Now to detect collision, we make sure we '''''SetTimer(9999)''''' for the script to stay up and looking for events, we add the Collision Handler to the projectile;
{| class="wikitable"
!Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
|}
and we wait for collisions;
{| class="wikitable"
!this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
|}
public function onProjectileCollisionEnter(gameobject, collision) {
temp.radius = 4;
temp.force = 5;

player.chat = "boom=" @ collision.Gameobject.name;
echo ("collision.Gameobject.name=" @ collision.Gameobject.name);

temp.explosion = Object::Instantiate(Type::GameObject, this.explosion);
temp.explosion.transform.parent = this.empty.transform;
temp.explosion.transform.position = collision.Gameobject.transform.position;
temp.explosion.transform.scale = v3(1,1,1);

temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
for (temp.col: temp.affected) {
if (temp.col.GetComponent(Type::RigidBody)!= NULL) {
temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
}
}

if (collision.Gameobject.name == "assets/jimmyminigame/robot.prefab(CLONE)") {
this.wreckedrobot = Object::Instantiate(Type::GameObject, this.wreckedrobotprefab);
this.wreckedrobot.transform.parent = this.empty.transform;
this.wreckedrobot.transform.position = collision.Gameobject.transform.position;;
Object::Destroy(collision.Gameobject);
}

if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;

Object::Destroy(gameobject);
}

==== New: Adding Explosion Force ====
Upon Collision, we instantiate and place the explosion. To make it seem more realistic we add an explosion force.

We first gather the Colliders around the area of explosion with a radius of 5;
{| class="wikitable"
!temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
|}
this will return a list of colliders in the sphere area around the explosion.

We then make sure they have a Rigid Body component and apply explosion force to them;
{| class="wikitable"
!temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
|}
In this conditional block we ignore the collision if it is between two projectiles;
{| class="wikitable"
!if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;
|}
function destroy() {
this.start = false;
echo("destroy");
Object::Destroy(this.turret);
Object::Destroy(this.launcher);
Object::Destroy(this.robot1);
Object::Destroy(this.robot2);
Object::Destroy(this.empty);
}

==== New : Destroying GameObjects ====
Here when the player says "dest"; this function is called and
{| class="wikitable"
!Object::Destroy(gameobject);
|}
is used to destroy the GameObject.

We can use this function with an added parameter that indicates the time in seconds to wait before destroying the GameObject;
{| class="wikitable"
!Object::Destroy(gameobject, seconds);
|}

Unity UI

2021-11-22T14:12:24Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]In this section we will go over an example of making a UI on unity and uploading and coding it on Client3D in graalscript.

Asset Bundles can be found here : <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=MenuUI.unitypackage</nowiki>

'''Unity Part:'''

Open the “Quattro3D- Unity Project for bundle asset creation” folder using unity hub.

To the assets folder, add we add a folder that will hold all the prefabs of the assetbundle.

To the scene, add a Canvas (in the Hierarchy, right click -> UI -> Canvas). The Canvas will hold all the elements of our UI (buttons, text, scrollbar, images…).

Select the Canvas and in the Inspector go to '''Canvas Scaler''' and select '''Scale With Screen''' for '''UI Scale Mode'''. This will allow the canvas Canvas to expand to full screen on all screens.

Now to build the UI you see above (devtools). Start by adding Text elements (right click on Canvas -> UI -> Text).

For each element, change the name and the text according to its function, change the color to white, add a button component and add a animation component. In the '''Rect Transform''' component, in the Anchor Presets, hold Alt and select top left to position your element.

Add all the Text elements and position them (Inspector, Bundle Explorer, Console, Camera, Rendering).

Now, to add the back button. Add an Image element to the UI, change its name to “back”, and in the image component add the source of the image (drop down in our case). Rotate it -90 deg on the Z axis for it to face left. Add a button component to turn it to a back button that closes the devtools.

For the grey background you see, add and image just like before, change its color to black and change the A field in RGBA to 48 to make it transparent. Add an '''Outline''' component and change the '''Effect Color''' to white to add an outline to the image.
[[File:Unity UI.png|none|thumb|1006x1006px]]

Now that we’ve added all our elements to the Canvas, it’s time to create our animations.

To create an animation, in the top menu (next to Files, Edit, Assets…) go to Window -> Animation -> Animation.

The animation tab should open in the bottom. Select the component you want to create an animation for and create and name the animation.

We will be doing the sliding background image example for the animation.

To record the animation, press on the record button. We want the image to slide in. So put the cursor on time 0s, and change the Pos X to -65 (outside of the screen) then move the cursor to 4s and change the Pos X back to 65. Press the record button again to save the recording.
[[File:Unity UI anim.png|none|thumb|1032x1032px]]

You can press play to view your animation in action. To add the animation to the element; simply add an animation component and add the source of the animation you just created.

Same thing goes for all the other animations.

'''Graal Script Part:'''

Now that we’ve created our prefabs and added the animations, our canvas is ready to be uploaded on the server and scripted. Save the AssetBundle and upload it to the server ([[Uploading and Loading AssetBundles]] for more info).
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
this.keepAlive = true;
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btnb: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}
We load the assetbundle the usual way:
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
'''''this.keepAlive = true;''''' is necessary for the weapon to keep checking for button clicks.

We create and instantiate the canvas prefab.
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);
this will display the canvas on the client screen.

To detect button clicks;
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
we first find the button GameObject by name ('''this.devui.transform''' being the transform component of the canvas, and '''btn''' is the button name we want to find).

Next, we add an EventManager to the button component of the GameObject we just found ('''temp.btn.gameobject.GetComponent(Type::UI::Button)''').

And '''this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick")''' to catch all the onClick events.

Finally, we implement '''public function onDevToolClick(go)''' to add functionalities after button is pressed (with '''go''' the GameObject being pressed).

For animations, to add or play an animation, you will need to get the animation component of the GameObject first. (using: '''temp.img.gameobject.GetComponent(Type::Animation)''')
temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
(more script functionalities for animations available here: https://docs.unity3d.com/ScriptReference/Animation.html).

Graal3D Scripting Manual

2021-11-18T14:17:37Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads: ====
'''Unity 2020.2.2f1:''' <nowiki>https://unity3d.com/get-unity/download/archive</nowiki>

'''The Worlds Client:''' <nowiki>https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-518.exe</nowiki>

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Graal3D Scripting Manual

2021-11-18T13:21:53Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads: ====
'''Unity 2020.2.2f1:''' <nowiki>https://unity3d.com/get-unity/download/archive</nowiki>

'''The Worlds Client:''' https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-516.exe

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

3DTutorials

2021-11-18T13:20:33Z

JimmyAkl:

This section contains Graal3D Tutorials/Minigames/Projects that have been done on the server.

Make sure you went over and reviewed the Documentation if you are new before starting the tutorials. ([[Getting Started Examples]])

More Unity functionalities and advanced topics will be covered here. Following these tutorials will definitely improve your understanding of the Graal Unity Binding and make you an overall better Graal3D developer.

===== MiniGames: =====

* [[Turret MiniGame]]
* [[Driving MiniGame]]
*[[Plane MiniGame]]
* [[Bomberman MiniGame]][[File:Camera05.jpg|thumb|749x749px|center]]

Graal3D Scripting Manual

2021-11-18T13:14:34Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads: ====
'''Unity 2020.2.2f1:''' <nowiki>https://unity3d.com/get-unity/download/archive</nowiki>

'''The Worlds Client:''' https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-516.exe

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Unity UI

2021-11-18T13:07:30Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]In this section we will go over an example of making a UI on unity and uploading and coding it on Client3D in graalscript.

'''Unity Part:'''

Open the “Quattro3D- Unity Project for bundle asset creation” folder using unity hub.

To the assets folder, add we add a folder that will hold all the prefabs of the assetbundle.

To the scene, add a Canvas (in the Hierarchy, right click -> UI -> Canvas). The Canvas will hold all the elements of our UI (buttons, text, scrollbar, images…).

Select the Canvas and in the Inspector go to '''Canvas Scaler''' and select '''Scale With Screen''' for '''UI Scale Mode'''. This will allow the canvas Canvas to expand to full screen on all screens.

Now to build the UI you see above (devtools). Start by adding Text elements (right click on Canvas -> UI -> Text).

For each element, change the name and the text according to its function, change the color to white, add a button component and add a animation component. In the '''Rect Transform''' component, in the Anchor Presets, hold Alt and select top left to position your element.

Add all the Text elements and position them (Inspector, Bundle Explorer, Console, Camera, Rendering).

Now, to add the back button. Add an Image element to the UI, change its name to “back”, and in the image component add the source of the image (drop down in our case). Rotate it -90 deg on the Z axis for it to face left. Add a button component to turn it to a back button that closes the devtools.

For the grey background you see, add and image just like before, change its color to black and change the A field in RGBA to 48 to make it transparent. Add an '''Outline''' component and change the '''Effect Color''' to white to add an outline to the image.
[[File:Unity UI.png|none|thumb|1006x1006px]]

Now that we’ve added all our elements to the Canvas, it’s time to create our animations.

To create an animation, in the top menu (next to Files, Edit, Assets…) go to Window -> Animation -> Animation.

The animation tab should open in the bottom. Select the component you want to create an animation for and create and name the animation.

We will be doing the sliding background image example for the animation.

To record the animation, press on the record button. We want the image to slide in. So put the cursor on time 0s, and change the Pos X to -65 (outside of the screen) then move the cursor to 4s and change the Pos X back to 65. Press the record button again to save the recording.
[[File:Unity UI anim.png|none|thumb|1032x1032px]]

You can press play to view your animation in action. To add the animation to the element; simply add an animation component and add the source of the animation you just created.

Same thing goes for all the other animations.

'''Graal Script Part:'''

Now that we’ve created our prefabs and added the animations, our canvas is ready to be uploaded on the server and scripted. Save the AssetBundle and upload it to the server ([[Uploading and Loading AssetBundles]] for more info).
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
this.keepAlive = true;
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btnb: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}
We load the assetbundle the usual way:
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
'''''this.keepAlive = true;''''' is necessary for the weapon to keep checking for button clicks.

We create and instantiate the canvas prefab.
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);
this will display the canvas on the client screen.

To detect button clicks;
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
we first find the button GameObject by name ('''this.devui.transform''' being the transform component of the canvas, and '''btn''' is the button name we want to find).

Next, we add an EventManager to the button component of the GameObject we just found ('''temp.btn.gameobject.GetComponent(Type::UI::Button)''').

And '''this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick")''' to catch all the onClick events.

Finally, we implement '''public function onDevToolClick(go)''' to add functionalities after button is pressed (with '''go''' the GameObject being pressed).

For animations, to add or play an animation, you will need to get the animation component of the GameObject first. (using: '''temp.img.gameobject.GetComponent(Type::Animation)''')
temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
(more script functionalities for animations available here: https://docs.unity3d.com/ScriptReference/Animation.html).

Turret MiniGame

2021-11-18T13:03:03Z

JimmyAkl:

Welcome to the Turret Minigame!

In this Tutorial, we will build a turret that rotates and shoots targets around it.

The Assets are available on the server.

==== TurretMiniGame GameObjects ====
All the prefabs are under the asset bundle: '''minigame''' (you can view them in the bundle explorer "F10")

Turret that shoots the projectiles:

[[File:Turret.png|frameless|407x407px]]

Robot that will serve as a target:

[[File:Robot Obstacle Minigame.png|frameless|407x407px]]

Cubes Instantiated in different position also for targets:

[[File:Turret Minigame targets.png|frameless|405x405px]]

findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "start") {
destroy();
start();
}
if (player.chat == "dest") destroy();
}
The way I start the minigame is '''onPlayerChats'''; when the player says "start". We'll also see how to '''destroy the GameObjects''' when the player says "dest".
function start() {
this.start = true;
//PLAYERMOVEMENT.Freeze();

//for turret control
this.rotateangle = 0; //Rotation angle of the turret
this.rotateangleB = 270; //Rotation angle of the barrel
this.speed = 15;

this.currentX = player.x;
this.currentY = player.y;
this.currentZ = player.z;
echo ("TurretMiniGame warp from=" @ this.currentLevel @ " x=" @ this.currentX @ " y=" @ this.currentY @ " z=" @ this.currentZ);
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
sleep(1.5);

(@"3D/Dev/AssetManager").loadAssetBundle("minigame"); //loading the assetbundle
}
'''''this.start = true;''''' will be used to indicate that the game has started.

==== New: Using PLAYERMOVEMENT and WARPMANAGER ====
'''PLAYERMOVEMENT.Freeze()''' is a method that freezes the player (weapon: '''3D/Player/Core/Movement)'''

'''WARPMANAGER.Warp(x,y,z,level)''' (weapon: '''3D/Player/Core/Warp/Manager''')

Having uploaded the Asset bundle called "'''minigame'''" that contains the prefabs to the server, I start off by loading them, creating the prefabs, instantiating them and giving them a position in the '''start function''' ([[Uploading and Loading AssetBundles|Uploading and Loading AssetBundles]] for info on how to upload assets).
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigame") {
SetTimer(9999);
this.empty = GameObject::Create("empty"); // for parenting and deleting

this.turret = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/turret.prefab");
this.robot1 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.robot2 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.wreckedrobotprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot wrecked.prefab");
this.projectileprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/projectile.prefab");
this.explosion = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/explosion.prefab");

this.turret = Object::Instantiate(Type::GameObject, this.turret);
this.robot1 = Object::Instantiate(Type::GameObject, this.robot1);
this.robot2 = Object::Instantiate(Type::GameObject, this.robot2);

this.turret.transform.position = v3(player.x, player.z, player.y);
this.robot1.transform.position = v3(player.x - 5, player.z - 1, player.y + 10);
this.robot2.transform.position = v3(player.x + 5, player.z - 1, player.y + 10);

this.turret.transform.localscale = v3(1,1,1);
this.robot1.transform.localscale = v3(1,1,1);
this.robot2.transform.localscale = v3(1,1,1);

loadCubes();

player.charactercontroller.enabled = false;
player.gameobject.transform.position = v3(player.x, player.z+5, player.y);

this.launcher = GameObject::Find("Launcher");
this.barrel = GameObject::Find("Barrel");
}
}

function loadCubes() {
temp.width = 10;
temp.height = 4;

for (temp.y = 0; temp.y < temp.height; ++temp.y) {
for (temp.x = 0; temp.x < temp.width; ++temp.x) {
temp.block = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.block.Name = "myblock";
temp.block.transform.parent = this.empty.transform; // for deleting
temp.block.transform.position = v3(player.x - 5 + temp.x, player.z + temp.y, player.y + 15);
temp.block.AddComponent(Type::RigidBody);
temp.block.layer = this.projectile.layer;
}
}

temp.nbofobjects = 20;
temp.radius = 7f;

for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.parent = this.empty.transform;
this.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
this.cube.AddComponent(Type::RigidBody);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
this.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
In the '''''loadCubes()''''' function we instantiate primitive type cubes and position them to build a wall and a circular formation around the turret.

==== New: Moving the Player GameObject ====
The player is a GameObject, and its accessed by:
{| class="wikitable"
!player.gameobject
|}
Before changing the player's transform, the '''''player.charactercontroller''''' must be disabled:
{| class="wikitable"
!player.charactercontroller.enabled = false;
|}
Then we can change the position accessing the transform component of the GameObject:
{| class="wikitable"
!player.gameobject.transform.position = Vector3::Create(player.x, player.z+5, player.y);
|}

==== New: Parenting ====
In Unity, parenting is when a GameObject becomes a parent of another GameObject. The child GameObject will perform all it's transform changes in respect to the parent GameObject and not the Camera. Additionally, deleting the parent GameObject will delete all its children.

We use it for the latter. We create the '''Empty GameObject''', which will serve as a parent for the Cubes ''(children)'' in order to delete them all, since we don't have a reference to each and every cube.

==== New: Finding GameObjects by Name ====
{| class="wikitable"
!GameObject::Find("name")
|}
We use it to find the barrel that we'll move up and down and the launcher that shoots the projectiles.

Now to move the Turret;
function onKeyPressed(keycode) {
if (keycode == "90") { // Z
this.rotateangle -= 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "67") { // C
this.rotateangle += 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "87") { // W
this.rotateangleB = this.rotateangleB < 300? this.rotateangleB + 4: 300;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "83") { // S
this.rotateangleB = this.rotateangleB > 258? this.rotateangleB - 4: 258;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "32, ,57") { // Space
if (this.start) {
shoot();
}
}
}
We rotate the barrel around the X axis for it to go up and down;
{| class="wikitable"
!Quaternion::euler(this.rotateangleB, 0, 0);
|}
And rotate the turret around the Y axis (Vertical axis);
{| class="wikitable"
!Quaternion::euler(0, this.rotateangle, 0);
|}
this.rotateangle for both cases starts at the initial rotation of the GameObjects and is incremented/decremented based on the direction of the rotation.

In the last conditional block, if space is pressed and if the Game is on ('''''this.start == true'''''), the projectile is shot. Here's how it's done;
function shoot() {
SetTimer(9999);
this.projectile = Object::Instantiate(Type::GameObject, this.projectileprefab);
this.projectile.transform.parent = this.empty.transform;
this.projectile.transform.position = this.launcher.transform.position;
this.projectile.transform.scale = v3(1,1,1);

temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);

Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
}
The projectile is initialized and positioned on the launcher.

We'll need to use physics to shoot the projectile, this is why we get the RigidBody component of the GameObject;
{| class="wikitable"
!temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
|}
(if the GameObject doesn't have a RigidBody by default, you'll need to add it using: '''''gameobject.AddComponent(Type::RigidBody);''''')

We then add velocity (which is a vector that represents speed in a certain direction). The direction is the Launcher's forward direction, it is multiplied by the desired speed;
{| class="wikitable"
!temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);
|}
Now to detect collision, we make sure we '''''SetTimer(9999)''''' for the script to stay up and looking for events, we add the Collision Handler to the projectile;
{| class="wikitable"
!Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
|}
and we wait for collisions;
{| class="wikitable"
!this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
|}
public function onProjectileCollisionEnter(gameobject, collision) {
temp.radius = 4;
temp.force = 5;

player.chat = "boom=" @ collision.Gameobject.name;
echo ("collision.Gameobject.name=" @ collision.Gameobject.name);

temp.explosion = Object::Instantiate(Type::GameObject, this.explosion);
temp.explosion.transform.parent = this.empty.transform;
temp.explosion.transform.position = collision.Gameobject.transform.position;
temp.explosion.transform.scale = v3(1,1,1);

temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
for (temp.col: temp.affected) {
if (temp.col.GetComponent(Type::RigidBody)!= NULL) {
temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
}
}

if (collision.Gameobject.name == "assets/jimmyminigame/robot.prefab(CLONE)") {
this.wreckedrobot = Object::Instantiate(Type::GameObject, this.wreckedrobotprefab);
this.wreckedrobot.transform.parent = this.empty.transform;
this.wreckedrobot.transform.position = collision.Gameobject.transform.position;;
Object::Destroy(collision.Gameobject);
}

if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;

Object::Destroy(gameobject);
}

==== New: Adding Explosion Force ====
Upon Collision, we instantiate and place the explosion. To make it seem more realistic we add an explosion force.

We first gather the Colliders around the area of explosion with a radius of 5;
{| class="wikitable"
!temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
|}
this will return a list of colliders in the sphere area around the explosion.

We then make sure they have a Rigid Body component and apply explosion force to them;
{| class="wikitable"
!temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
|}
In this conditional block we ignore the collision if it is between two projectiles;
{| class="wikitable"
!if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;
|}
function destroy() {
this.start = false;
echo("destroy");
Object::Destroy(this.turret);
Object::Destroy(this.launcher);
Object::Destroy(this.robot1);
Object::Destroy(this.robot2);
Object::Destroy(this.empty);
}

==== New : Destroying GameObjects ====
Here when the player says "dest"; this function is called and
{| class="wikitable"
!Object::Destroy(gameobject);
|}
is used to destroy the GameObject.

We can use this function with an added parameter that indicates the time in seconds to wait before destroying the GameObject;
{| class="wikitable"
!Object::Destroy(gameobject, seconds);
|}

Graal3D Scripting Manual

2021-11-18T12:28:09Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads: ====
'''Unity 2020.2.2f1:''' [https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-515.exe https://unity3d.com/get-unity/download/archive]

'''The Worlds Client:''' https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-516.exe

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Graal3D Scripting Manual

2021-11-14T19:42:41Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads: ====
'''Unity 2020.2.2f1:''' [https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-515.exe https://unity3d.com/get-unity/download/archive]

'''The Worlds Client:''' https://www.graalonline.com/playerworlds/downloads/file?name=WorldsSetup64-516.exe

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Bomberman MiniGame

2021-10-15T07:20:27Z

JimmyAkl:

Welcome to the Bomberman Minigame Tutorial!

= BomberMan =

==== Intro ====
BomberMan is a multiplayer game (usually 4 players). Each player can drop bombs that, upon explosion, destroy the grey pillars making a path to other players. The objective of the game is to eliminate other players with the exploding bombs. Power ups are also sometimes dropped when pillars are destroyed (increase of speed, explosion power and number of bombs allowed to place at a time).
[[File:Bomberman cover.png|none|thumb|675x675px]]
Assets are available on the server under:

'''bombermanprefabs'''

[[File:Bomberman prefabs.png|frameless]]

and '''bombermanlevel1'''

[[File:Bomberman level prefab.png|frameless]]

Since this game is meant to be multiplayer, we will be placing the GameObjects in NPCs for them to be visible to all the players and triggerring the server every time we want to place them. (more info on that here: [[Placing GameObjects in NPC]])

First, we have the weapon that launches the game and places the NPCs (''found under '''weapon: 3D/Samples/BomberMan/Game''''')

We've implemented a graalscript UI (which is not covered in this section, considering you know graalscript) that allows us to launch the game;
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
//temp.pnpc.DropBomb(explvl);
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}

//#CLIENTSIDE
function onCreated() {
echo(this.name @ " OnCreated");
}

public function Load() {
level.explosionpower = 3; //for powerups with explosion
level.numberofbombs = 2; //number of bombs allowed to place at a time
level.speed = 7; //player default speed

echo(this.name @ " LOAD");
Object::destroy(this.bomberManParentNode);
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
new GuiButtonCtrl("bomberman_Quit") {
profile = GuiBlueButtonProfile;
x = 600;
y = 200;
width = 150;
height = 30;
text = "bombermanQuit";
}

temp.warpLevel = "only_ground.nw";
temp.warpX = 4.65;
temp.warpY = 21.33;
temp.warpZ = 0.7;
WARPMANAGER.Warp(temp.warpX, temp.warpY ,temp.warpZ ,temp.warpLevel);
sleep(0.5);
start();
}

function bomberman_Quit.onAction() {
BomberManQuit();
}

public function BomberManQuit() {
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
PLAYERMOVEMENT.UnFreeze();
PLAYERMOVEMENT.canJump = true;
this.GAMEON = false;
}

function start() {
PLAYERMOVEMENT.canJump = false;
this.GAMEON = true;
triggerserver("gui", this.name, "level", -60 , 14);
}

function onKeyPressed(keycode, keychar) {
if (this.GAMEON == true) {
if (keycode == "32, ,57") {
DropBomb();
}
}
}

function DropBomb() {
this.hit = RaycastHit::create();
done = Physics::Raycast(player.gameobject.transform.position, Vector3::Down, this.hit, 100);
//sleep(0.05);
triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}

the '''''Load()''''' function is called when the minigame is launched (Devtools -> Minigames -> BomberMan).

'''level.explosionpower = 3;''' is how much tiles the explosion is going to cover. (at the beginning it's 3)

'''level.numberofbombs = 2;''' is the number of bombs a player is allowed to place at a time. (at the beginning it's 2)

In the function '''''start()''''', we trigger the server with the command "'''level'''" to load the bomberman map by placing an NPC and joining it with the class "'''3d_samples_bomberman_level'''".

Once we start the game, the player is not allowed to Jump: '''PLAYERMOVEMENT.canJump = false;'''

And pressing space will be used to drop a bomb, '''''function onKeyPressed()''''' checks if space is pressed and calls '''''DropBomb()'''.''

==== New: RayCast: ====
Think of RayCast as '''''triggeraction()''''' that triggers NPCs at a given (x,y). Similarly, '''''RayCast''''' casts a ray given a position (origin), a direction and a length, detecting colliders.
{| class="wikitable"
!Raycast(Vector3 origin, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);
|}
'''Returns:''' Boolean indicating if the RayCast hit a Collider.

''(More info here: https://docs.unity3d.com/ScriptReference/Physics.Raycast.html<nowiki/>)''

Here, since the bomberman level is a grid and the floor is made of squares. We want the player to drop the bomb exactly in one square and not in between two. Therefore, when space is pressed, we RayCast with the PlayerGameObject as '''origin''', with a Vector3::Down '''direction''', '''''this.hit''''' as the '''output''' and 100 for '''length'''. The other parameters are kept as default.

This will return the collider of the GameObject underneath the player, which is one square tile.

We extract the tile's position from '''''this.hit''''':
{| class="wikitable"
!this.hit.transform.gameobject.transform.position.x / y
|}
And we trigger the server, with the command "bomb" and the coordinates, to place a bomb NPC;
{| class="wikitable"
!triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
|}
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}
Now, on to the classes!

'''"3d_samples_bomberman_level" Class:'''
function onCreated() {
//Set a 10 minute timer to automatically destroy the levelprefab
scheduleEvent(120, "DestLvl");
}
//Destroy if the server restarts

function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "dest") onDestLvl();
}

function onDestLvl() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
(@"3D/Dev/AssetManager").loadAssetBundle("bombermanlevel1");
}

function onAssetBundleDownloaded(bundlename){
if (bundlename == "bombermanlevel1") {
player.chat = "bombermanlevel loaded";
temp.prefab = GameObject::fromassetbundle("bombermanlevel1", "assets/bombermantest/big level 2.prefab");
this.bomberlevel = Object::Instantiate(Type::GameObject, temp.prefab, this.gameobject.transform, false);
this.bomberlevel.transform.parent = this.gameobject.transform;
this.bomberlevel.transform.localposition = v3(-15,0,0);
this.bomberlevel.transform.localscale = v3(1,1,1);
}
}

function onPlayerChats() {
if (player.chat == "dest") Object::Destroy(this.gameobject);
}
Here we place the level GameObject in an NPC ([[Placing GameObjects in NPC]]) and we only load and instantiate the level the usual way ([[Uploading and Loading AssetBundles]]).

'''"3d_samples_bomberman_bomb" Class:'''
function onCreated() {
//echo("merlin_testbomb");
scheduleEvent(3600, "RemoveBomb");
}

//Destroy if the server restarts
function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "/destroy") {
onRemoveBomb();
}
}

function onRemoveBomb() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
this.dropped = false;
this.powerup = randomstring({"bomb", "explosion", "speed"});

DropBomb();
}

function DropBomb() {
if (level.numberofbombs == 0) return;
--level.numberofbombs;

(@"3D/Dev/AssetManager").loadAssetBundle("bombermanprefabs");
(@"3D/Dev/AssetManager").loadAssetBundle("staffstick");
this.speedprefab = GameObject::fromassetbundle("staffstick","assets/johntest/staffstick_era.prefab");
this.explosionprefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/explosion.prefab");
this.prefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/bomb.prefab");
this.bomb = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localeulerangles = v3(0, 0, 0);
this.bomb.transform.localposition = v3(0, 0.5, 0);

scheduleEvent(3, "Explode");
}

function onExplode() {
echo("onexplode");

echo ("prefab type=" @ this.explosionprefab.objecttype());
this.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
echo ("explosion type=" @ this.explosion.objecttype());
this.explosion.transform.parent = this.gameobject.transform;
this.explosion.transform.localposition = v3(0, 0, 0);
this.explosion.transform.localscale = v3(1,1,1);

Object::Destroy(this.bomb, .3f);

this.exploded = true;

CreateExplosion(Vector3::forward);
CreateExplosion(Vector3::right);
CreateExplosion(Vector3::back);
CreateExplosion(Vector3::left);

++level.numberofbombs;
}

function CreateExplosion(direction) {
for (temp.i = 1; temp.i < level.explosionpower; temp.i++) {
this.hit = RaycastHit::create();
done = Physics::Raycast(this.bomb.transform.position.Add(v3(0,0.5,0)), direction, this.hit, temp.i);

if (!done || this.hit.transform.gameobject.name.starts("assets/bomberman/prefabs/explosion.prefab") || this.hit.transform.gameobject.name.starts("TPlayer")){
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.localposition = v3(0,0,0).Add(direction.Mult(temp.i));
Object::Destroy(temp.explosion, 0.7);
}
if (this.hit.transform.gameobject.name.starts("E_Bomber_Pilar_01_")|| this.hit.transform.gameobject.transform.parent.gameobject.name.starts("E_Bomber_Pilar_01_")) {
if (!this.dropped) {
if (rand(0,1) < 0.2) {
this.dropped = true;
//drop power up
droppowerup(this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}
}
Object::Destroy(this.hit.transform.gameobject.transform.parent.gameobject);
Object::Destroy(this.hit.transform.gameobject);
Object::Destroy(temp.explosion, 0.7);
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.position = this.hit.transform.position;
}
}
}

function droppowerup(x,z) {
if (this.powerup == "bomb") {
this.powerupGO = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
}
if (this.powerup == "explosion") {
this.powerupGO = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
}
if (this.powerup == "speed") {
this.powerupGO = Object::instantiate(Type::GameObject, this.speedprefab, this.gameobject.transform, false);
}
this.powerupGO.transform.position = v3(x, 0.5, z);
this.powerupGO.transform.scale = v3(0.5,0.5,0.5);

sphereCollider = this.powerupGO.AddComponent(Type::SphereCollider);
sphereCollider.size = v3(1, 10, 1);
}

public function onActionGrab() {
player.chat = this.powerup;
Object::Destroy(this.gameobject);
if (this.powerup == "bomb") {
++level.numberofbombs;
}
if (this.powerup == "explosion") {
++level.explosionpower;
}
if (this.powerup == "speed") {
PLAYERMOVEMENT.setSpeed(7);
}
}
Again, we are loading and instantiating the prefabs in an NPC.

In '''''function onCreated()''''':

* '''''this.dropped''''' variable is used to allow every bomb to drop only one powerup.
* '''''this.powerup''''' variable is the name of the powerup, chosen randomly each time a bomb is dropped.

'''''DropBomb()''''' is responsible for loading, instantiating and placing the bomb. The player can drop 2 bombs at a time at the start of the game. Therefore, we begin by checking if the player can drop bombs. We decrease the variable '''''level.numberofbombs''''' when a bomb is dropped and decrease it when the bomb explodes.

After positioning the bomb, we schedule event to create the explosion after 3 seconds of placing the bomb;
{| class="wikitable"
!scheduleEvent(3, "Explode");
|}
'''''onExplode()''''' function instantiates an explosion under the bomb;
{| class="wikitable"
!this.explosion.transform.localposition = v3(0, 0, 0);
|}
and calls '''''CreateExplosion(direction);''''' in all the four directions (forward, right, left, back) to instantiate explosions in a cross shape around the bomb.

'''''CreateExplosion(direction)''''' casts a Ray in all the four directions with the given length ('''level.explosionpower'''; the number of tiles it covers) and the bomb as the origin.
{| class="wikitable"
!this.bomb.transform.position.Add(v3(0,0.5,0));
|}we add a '''''Vector3 (0, 0.5, 0)''''' to increase the Y of the '''RayCast''' for it to hit the grey pillars and not the ground.

The two conditional blocks after are used to check if the collider hit by the raycast is a pillar or not.

if it's a Grey Pillar, we destroy it. If not then it's empty space and we instantiate an explosion.

When a Pillar is destroyed, there's a 20% chance it will drop a powerup, by calling the function '''''droppowerup(x,z)''''' with (x,z) the coordinates of the Pillar.

'''''droppowerup(x,z)''''' will check '''''this.powerup''''' and create and place the appropriate GameObject. It also adds a collider Component to be triggered onActionGrab;

==== New: onActionGrab for NPCs: ====
For this to work, the GameObject is required to have a collider.

And '''''public function onActionGrab()''''' needs to be implemented.

Here, we destroy the powerup GameObject and give the player the powerup.

(''weapon: '''3D/Player/Grab''''' for more info)

Unity UI

2021-10-15T07:12:19Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]In this section we will go over an example of making a UI on unity and uploading and coding it on Client3D in graalscript.

'''Unity Part:'''

Open the “Quattro3D- Unity Project for bundle asset creation” folder using unity hub.

To the assets folder, add we add a folder that will hold all the prefabs of the assetbundle.

To the scene, add a Canvas (in the Hierarchy, right click -> UI -> Canvas). The Canvas will hold all the elements of our UI (buttons, text, scrollbar, images…).

Select the Canvas and in the Inspector go to '''Canvas Scaler''' and select '''Scale With Screen''' for '''UI Scale Mode'''. This will allow the canvas Canvas to expand to full screen on all screens.

Now to build the UI you see above (devtools). Start by adding Text elements (right click on Canvas -> UI -> Text).

For each element, change the name and the text according to its function, change the color to white, add a button component and add a animation component. In the '''Rect Transform''' component, in the Anchor Presets, hold Alt and select top left to position your element.

Add all the Text elements and position them (Inspector, Bundle Explorer, Console, Camera, Rendering).

Now, to add the back button. Add an Image element to the UI, change its name to “back”, and in the image component add the source of the image (drop down in our case). Rotate it -90 deg on the Z axis for it to face left. Add a button component to turn it to a back button that closes the devtools.

For the grey background you see, add and image just like before, change its color to black and change the A field in RGBA to 48 to make it transparent. Add an '''Outline''' component and change the '''Effect Color''' to white to add an outline to the image.
[[File:Unity UI.png|none|thumb|1006x1006px]]

Now that we’ve added all our elements to the Canvas, it’s time to create our animations.

To create an animation, in the top menu (next to Files, Edit, Assets…) go to Window -> Animation -> Animation.

The animation tab should open in the bottom. Select the component you want to create an animation for and create and name the animation.

We will be doing the sliding background image example for the animation.

To record the animation, press on the record button. We want the image to slide in. So put the cursor on time 0s, and change the Pos X to -65 (outside of the screen) then move the cursor to 4s and change the Pos X back to 65. Press the record button again to save the recording.
[[File:Unity UI anim.png|none|thumb|1032x1032px]]

You can press play to view your animation in action. To add the animation to the element; simply add an animation component and add the source of the animation you just created.

Same thing goes for all the other animations.

'''Graal Script Part:'''

Now that we’ve created our prefabs and added the animations, our canvas is ready to be uploaded on the server and scripted. Save the AssetBundle and upload it to the server ([[Uploading and Loading AssetBundles]] for more info).
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
this.keepAlive = true;;
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btnb: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}
We load the assetbundle the usual way:
(@"3D/Dev/AssetManager").loadAssetBundle("devtoolsui");
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
'''''this.keepAlive = true;''''' is necessary for the weapon to keep checking for button clicks.

We create and instantiate the canvas prefab.
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);
this will display the canvas on the client screen.

To detect button clicks;
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
we first find the button GameObject by name ('''this.devui.transform''' being the transform component of the canvas, and '''btn''' is the button name we want to find).

Next, we add an EventManager to the button component of the GameObject we just found ('''temp.btn.gameobject.GetComponent(Type::UI::Button)''').

And '''this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick")''' to catch all the onClick events.

Finally, we implement '''public function onDevToolClick(go)''' to add functionalities after button is pressed (with '''go''' the GameObject being pressed).

For animations, to add or play an animation, you will need to get the animation component of the GameObject first. (using: '''temp.img.gameobject.GetComponent(Type::Animation)''')
temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
(more script functionalities for animations available here: https://docs.unity3d.com/ScriptReference/Animation.html).

Category:Creation

2021-10-15T07:06:06Z

JimmyAkl:

[[Category:Table_Of_Contents]]
{{template:Creation}}

Creation

2021-10-15T07:05:52Z

JimmyAkl:

[[Category:Creation]]
{{template:Creation}}
Graal3D

* [[Graal3D Scripting Manual]]

Plane MiniGame

2021-10-12T12:20:46Z

JimmyAkl:

This minigame is similar to the Car driving minigame. However, we move a plane through obstacles.

'''AssetBundles:''' ''minigameplane - env''

using the bundle explorer (F10):

'''minigameplane:'''

[[File:Plane.png|frameless]]

[[File:Obstacles.png|frameless]]

'''env:'''

[[File:Environment.png|frameless]]

Weapon: '''''3D/Samples/Planeminigame'''''
findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE

function onCreated() {
this.keepAlive = true;//SetTimer(9999);
}

function onPlayerChats() {
if (player.chat == "plane") start();
}

public function start() {
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
new GuiWindowCtrl("PlaneMinigame") {
profile = GuiBlueWindowProfile;
x = 120;
y = 0;
width = 670;
height = 340;
text = "Plane Minigame";

new GuiButtonCtrl("Plane") {
profile = GuiBlueButtonProfile;
x = 150;
y = 90;
width = 150;
height = 30;
text = "Spawnplane";
}
new GuiButtonCtrl("Exit") {
profile = GuiBlueButtonProfile;
x = 150;
y = 120;
width = 150;
height = 30;
text = "Exit";
}
}
}

function Plane.onAction() {
exit();
PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANGER.freecam = true;
this.empty = GameObject::Create("empty");
Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
(@"3D/Dev/AssetManager").loadAssetBundle("minigameplane");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigameplane") {
this.planeprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/small_plane02.prefab");
this.plane = Object::Instantiate(Type::GameObject, this.planeprefab);
this.plane.transform.position = v3(player.x, player.z, player.y);
this.plane.transform.localscale = v3(0.3, 0.3, 0.3);
this.plane.transform.parent = this.empty.transform;

this.RB = this.plane.AddComponent(Type::RigidBody);
this.RB.useGravity = false;

boxCollider = this.plane.AddComponent(Type::BoxCollider);
boxCollider.size = v3(4,4,4);

Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");

this.obstacleprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/obstacles 1.prefab");
this.obstacle = Object::Instantiate(Type::GameObject, this.obstacleprefab);
this.obstacle.transform.position = v3(player.x, player.z + 10, player.y + 20);
this.obstacle.transform.localscale = v3(0.3, 0.3, 0.3);
this.obstacle.transform.parent = this.empty.transform;
}
if (bundlename == "env") {
this.envprefab = GameObject::fromassetbundle("env", "assets/jimmyenv2/environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.envprefab);
this.env.transform.position = v3(player.x, player.z + 1.5, player.y);
this.env.transform.parent = this.empty.transform;
}
}

function onUpdate() {
temp.campos = this.plane.transform.position.Add(v3(20,0,0));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

this.verticalInput = Input::GetAxis("Vertical");
this.horizontalInput = Input::GetAxis("Horizontal");

this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));

this.plane.transform.rotate(Vector3::Right.Mult(700 * Time::deltaTime * this.verticalInput));

this.plane.transform.rotate(Vector3::Forward.Mult(700 * Time::deltaTime * this.horizontalInput * -1));

this.propellor = this.plane.transform.Find("Propellor");
this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));
}

public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

function Exit.onAction() {
exit();
}

function exit() {
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.empty);
Input::ResetInputAxes();
}

The function '''''start()''''' creates a UI with two buttons (Spawn Plane and Exit) allowing us to start and end the game.

'''Plane.onAction()''' ''(when the Spawn button is pressed) :''

Calls the '''''exit()''''' function first to destroy GameObjects instantiated before, freezes the player using '''PLAYERMOVEMENT.Freeze();''' ,frees the camera with '''Quattro3D::PlayerCamera::Instance.FreeCam = true;''' and loads all the assets we'll need to use.

In function '''''onAssetBundleDownloaded(bundlename)''''' we catch all the loaded assetbundles, we instantiate the plane, obstacles and environment. And we position them, modify their scales, add components to them and make them a child of an empty GameObject.
{| class="wikitable"
!this.empty = GameObject::Create("empty");
|}
{| class="wikitable"
!this.obstacle.transform.parent = this.empty.transform;
|}
This will help delete all the GameObjects upon deleting the empty GameObject. ('''Object::Destroy(this.empty);''')

Now, the '''''onUpdate()''''' function checks for updates on every frame. '''''SetTimer(9999)''''' needs to be added for it to work.

This function will be responsible for moving the plane, moving the camera following the plane and turning the propeller of the plane.

First for the Camera, we want it to be looking side ways at the plane. We take the plane's position and add to the X axis:
{| class="wikitable"
!temp.campos = this.plane.transform.position.Add(v3(20,0,0));
|}
then we change the camera position to '''''temp.campos;'''''
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;
|}
We'll also need to change the rotation of the camera since it's initially facing forward and we want it to face the plane;
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
|}
Now, for the movement of the plane. It will be moving forward at a constant speed; '''''this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));'''''

And the '''''Input::GetAxis()''''' will help us move it up/down and sideways.

We also find the propellor of the plane and move it at a constant rotation speed;

'''''this.propellor = this.plane.transform.Find("Propellor");'''''

'''''this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));'''''

Finally, the function '''''exit()''''' switches back to the default camera: '''''findweapon("3D/Dev/ToolBar/Camera").cam1();'''''

unfreezes the Player, destroys the GameObjects and resets the Input Axes using: '''''Input::ResetInputAxes();'''''
[[File:Planeminigame gameplay.png|center|thumb|1108x1108px]]You can also add collision detection to the plane to turn it into an actual game.
Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");
and implement the function:
public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

Driving MiniGame

2021-10-12T12:19:40Z

JimmyAkl:

Welcome to the Driving MiniGame tutorial.

= Intro =

==== DrivingMiniGame ====
This is a simple and easy car driving example. In the assetbundle, there's an environment that we load and instantiate and multiple cars that we can spawn. This game is not focused on the actual driving experience itself, but more on introducing new Unity functionalities.

'''Asset Bundles: ''minigame2, env'''''

using the bundle explorer (F10):

'''minigame2:'''

[[File:Minigame2.png|frameless]]

'''env:'''

[[File:Minigame2 env.png|frameless]]

Weapon: '''''3D/Samples/Drivingminigame'''''
findplayer("GraalID").addweapon(this.name);
this.join("3d_merlin_camera");

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "dest") dest();
if (player.chat == "drive") drive();
}

function drive() {
destLevelName = "only_ground.nw";
x = 19;
y = 10;
z = 0.7;//0.7;
WARPMANAGER.Warp(x, y ,z ,destLevelName);

sleep(1);

new GuiWindowCtrl("MyGUI_Minigame_Window1") {
profile = GuiBlueWindowProfile;
style = $pref::Video::defaultguistyle;
clientrelative = true;
clientextent = "320,240";

canmove = true;
canresize = true;
closequery = false;
destroyonhide = false;
text = "Window 1";
x = 490;
y = 242;

new GuiButtonCtrl("MyGUI_Minigame_Button1") {
profile = GuiBlueButtonProfile;
text = "Car";
width = 80;
x = 77;
y = 31;
}
new GuiButtonCtrl("MyGUI_Minigame_Button2") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Bus";
width = 80;
x = 77;
y = 69;
}
new GuiButtonCtrl("MyGUI_Minigame_Button3") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Quit";
width = 80;
x = 78;
y = 109;
}
new GuiTextCtrl("MyGUI_Minigame_Text1") {
profile = GuiBlueTextProfile;
height = 20;
text = "Select Type:";
width = 71;
x = 11;
y = 5;
}
}
}

function MyGUI_Minigame_Button1.onAction() {
// Button "Car" has been pressed
(@"3D/Dev/AssetManager").loadAssetBundle("minigame2");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
this.vehicle = "car";
}

function MyGUI_Minigame_Button2.onAction() {
// Button "Bus" has been pressed
(@"3D/Dev/AssetManager").loadAssetBundle("minigame2");
(@"3D/Dev/AssetManager").loadAssetBundle("env");
this.vehicle = "bus";
}

function MyGUI_Minigame_Button3.onAction() {
dest();
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "env") {
this.env = GameObject::fromassetbundle("env", "assets/jimmyenv2/Environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.env);
this.env.transform.position = v3(player.x, player.z, player.y);
}
if (bundlename == "minigame2") {
if (this.vehicle == "bus") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Bus_Blue_Z.prefab");
}

if (this.vehicle == "car") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Car_Blue_Z.prefab");
}

this.vh = Object::Instantiate(Type::GameObject, this.vh);
this.vh.transform.position = v3(player.x - 2, player.z, player.y - 5);
this.vh.AddComponent(Type::RigidBody);

PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANAGER.freecam = true;
handleMovement();
}
}

function handleMovement() {
this.on = true;
SetTimer(0.05);
this.speed = 20;
this.rotation = 400;
}

function onFixedUpdate() {
this.vInput = Input::GetAxis("Vertical");
this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

this.hInput = Input::GetAxis("Horizontal");
this.vh.transform.Rotate(Vector3::up.Mult(Time::deltaTime * this.rotation * this.hInput * this.vInput));
}

function onTimeOut() {
if(this.on) {
temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

//this.vInput = Input::GetAxis("Vertical");

//this.hInput = Input::GetAxis("Horizontal");
//if (this.vInput < 0) this.hInput = - Input::GetAxis("Horizontal");

//this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

SetTimer(0.05);
}
}

function dest() {
this.on = false;
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.vh);
Object::Destroy(this.env);
}

Here we create a UI for the player to choose what vehicle to choose, and we load and instantiate the prefab based on the choice.

==== New: Camera ====
The Camera is the point of view. Here we want the Camera to follow the car while driving and not the player.

In '''''function onAssetBundleDownloaded(bundlename)''''' We use:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.FreeCam = true;
|}
To free the camera. This will free it from following the player GameObject.

Then in '''''function onTimeOut()''''' we want the camera position to be updated with the vehicle's position.

'''''temp.campos''''' is the variable we store the camera's position in. We want it to be behind and above the vehicle for a good view. This is why we get the vehicle's position and add a Vector3 to it:
{| class="wikitable"
!temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
|}
now:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position
|}
allows us to the get the Camera GameObject and to access its transform component and change its position.

We have implemented default cameras found in Weapon: '''''3D/Dev/ToolBar/Camera'''''

We access them through the Weapon "'''''3D/Dev/ToolBar/Camera'''''" using:
{| class="wikitable"
!''findweapon("3D/Dev/ToolBar/Camera").cam1();''
|}and we call the function '''''cam1();''''' in '''''function dest()''''' to go back to the default cam.

==== New: Unity Input ====
{| class="wikitable"
!Input::GetAxis("Vertical");
|}
"Vertical" / "Horizontal"

It checks the arrows pressed and gives a value in the range of (-1 to 1) -1 indicating "down", 1 "up" and 0 "neutral".

We use it here to translate and rotate the vehicle.

Turret MiniGame

2021-10-12T12:17:29Z

JimmyAkl:

Welcome to the Turret Minigame!

In this Tutorial, we will build a turret that rotates and shoots targets around it. The Assets are available on the server.

==== TurretMiniGame GameObjects ====
All the prefabs are under the asset bundle: '''minigame''' (you can view them in the bundle explorer "F10")

Turret that shoots the projectiles:

[[File:Turret.png|frameless|407x407px]]

Robot that will serve as a target:

[[File:Robot Obstacle Minigame.png|frameless|407x407px]]

Cubes Instantiated in different position also for targets:

[[File:Turret Minigame targets.png|frameless|405x405px]]

findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "start") {
destroy();
start();
}
if (player.chat == "dest") destroy();
}
The way I start the minigame is '''onPlayerChats'''; when the player says "start". We'll also see how to '''destroy the GameObjects''' when the player says "dest".
function start() {
this.start = true;
//PLAYERMOVEMENT.Freeze();

//for turret control
this.rotateangle = 0; //Rotation angle of the turret
this.rotateangleB = 270; //Rotation angle of the barrel
this.speed = 15;

this.currentX = player.x;
this.currentY = player.y;
this.currentZ = player.z;
echo ("TurretMiniGame warp from=" @ this.currentLevel @ " x=" @ this.currentX @ " y=" @ this.currentY @ " z=" @ this.currentZ);
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
sleep(1.5);

(@"3D/Dev/AssetManager").loadAssetBundle("minigame"); //loading the assetbundle
}
'''''this.start = true;''''' will be used to indicate that the game has started.

==== New: Using PLAYERMOVEMENT and WARPMANAGER ====
'''PLAYERMOVEMENT.Freeze()''' is a method that freezes the player (weapon: '''3D/Player/Core/Movement)'''

'''WARPMANAGER.Warp(x,y,z,level)''' (weapon: '''3D/Player/Core/Warp/Manager''')

Having uploaded the Asset bundle called "'''minigame'''" that contains the prefabs to the server, I start off by loading them, creating the prefabs, instantiating them and giving them a position in the '''start function''' ([[Uploading and Loading AssetBundles|Uploading and Loading AssetBundles]] for info on how to upload assets).
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigame") {
SetTimer(9999);
this.empty = GameObject::Create("empty"); // for parenting and deleting

this.turret = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/turret.prefab");
this.robot1 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.robot2 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.wreckedrobotprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot wrecked.prefab");
this.projectileprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/projectile.prefab");
this.explosion = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/explosion.prefab");

this.turret = Object::Instantiate(Type::GameObject, this.turret);
this.robot1 = Object::Instantiate(Type::GameObject, this.robot1);
this.robot2 = Object::Instantiate(Type::GameObject, this.robot2);

this.turret.transform.position = v3(player.x, player.z, player.y);
this.robot1.transform.position = v3(player.x - 5, player.z - 1, player.y + 10);
this.robot2.transform.position = v3(player.x + 5, player.z - 1, player.y + 10);

this.turret.transform.localscale = v3(1,1,1);
this.robot1.transform.localscale = v3(1,1,1);
this.robot2.transform.localscale = v3(1,1,1);

loadCubes();

player.charactercontroller.enabled = false;
player.gameobject.transform.position = v3(player.x, player.z+5, player.y);

this.launcher = GameObject::Find("Launcher");
this.barrel = GameObject::Find("Barrel");
}
}

function loadCubes() {
temp.width = 10;
temp.height = 4;

for (temp.y = 0; temp.y < temp.height; ++temp.y) {
for (temp.x = 0; temp.x < temp.width; ++temp.x) {
temp.block = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.block.Name = "myblock";
temp.block.transform.parent = this.empty.transform; // for deleting
temp.block.transform.position = v3(player.x - 5 + temp.x, player.z + temp.y, player.y + 15);
temp.block.AddComponent(Type::RigidBody);
temp.block.layer = this.projectile.layer;
}
}

temp.nbofobjects = 20;
temp.radius = 7f;

for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.parent = this.empty.transform;
this.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
this.cube.AddComponent(Type::RigidBody);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
this.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
In the '''''loadCubes()''''' function we instantiate primitive type cubes and position them to build a wall and a circular formation around the turret.

==== New: Moving the Player GameObject ====
The player is a GameObject, and its accessed by:
{| class="wikitable"
!player.gameobject
|}
Before changing the player's transform, the '''''player.charactercontroller''''' must be disabled:
{| class="wikitable"
!player.charactercontroller.enabled = false;
|}
Then we can change the position accessing the transform component of the GameObject:
{| class="wikitable"
!player.gameobject.transform.position = Vector3::Create(player.x, player.z+5, player.y);
|}

==== New: Parenting ====
In Unity, parenting is when a GameObject becomes a parent of another GameObject. The child GameObject will perform all it's transform changes in respect to the parent GameObject and not the Camera. Additionally, deleting the parent GameObject will delete all its children.

We use it for the latter. We create the '''Empty GameObject''', which will serve as a parent for the Cubes ''(children)'' in order to delete them all, since we don't have a reference to each and every cube.

==== New: Finding GameObjects by Name ====
{| class="wikitable"
!GameObject::Find("name")
|}
We use it to find the barrel that we'll move up and down and the launcher that shoots the projectiles.

Now to move the Turret;
function onKeyPressed(keycode) {
if (keycode == "90") { // Z
this.rotateangle -= 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "67") { // C
this.rotateangle += 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "87") { // W
this.rotateangleB = this.rotateangleB < 300? this.rotateangleB + 4: 300;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "83") { // S
this.rotateangleB = this.rotateangleB > 258? this.rotateangleB - 4: 258;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "32, ,57") { // Space
if (this.start) {
shoot();
}
}
}
We rotate the barrel around the X axis for it to go up and down;
{| class="wikitable"
!Quaternion::euler(this.rotateangleB, 0, 0);
|}
And rotate the turret around the Y axis (Vertical axis);
{| class="wikitable"
!Quaternion::euler(0, this.rotateangle, 0);
|}
this.rotateangle for both cases starts at the initial rotation of the GameObjects and is incremented/decremented based on the direction of the rotation.

In the last conditional block, if space is pressed and if the Game is on ('''''this.start == true'''''), the projectile is shot. Here's how it's done;
function shoot() {
SetTimer(9999);
this.projectile = Object::Instantiate(Type::GameObject, this.projectileprefab);
this.projectile.transform.parent = this.empty.transform;
this.projectile.transform.position = this.launcher.transform.position;
this.projectile.transform.scale = v3(1,1,1);

temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);

Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
}
The projectile is initialized and positioned on the launcher.

We'll need to use physics to shoot the projectile, this is why we get the RigidBody component of the GameObject;
{| class="wikitable"
!temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
|}
(if the GameObject doesn't have a RigidBody by default, you'll need to add it using: '''''gameobject.AddComponent(Type::RigidBody);''''')

We then add velocity (which is a vector that represents speed in a certain direction). The direction is the Launcher's forward direction, it is multiplied by the desired speed;
{| class="wikitable"
!temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);
|}
Now to detect collision, we make sure we '''''SetTimer(9999)''''' for the script to stay up and looking for events, we add the Collision Handler to the projectile;
{| class="wikitable"
!Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
|}
and we wait for collisions;
{| class="wikitable"
!this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
|}
public function onProjectileCollisionEnter(gameobject, collision) {
temp.radius = 4;
temp.force = 5;

player.chat = "boom=" @ collision.Gameobject.name;
echo ("collision.Gameobject.name=" @ collision.Gameobject.name);

temp.explosion = Object::Instantiate(Type::GameObject, this.explosion);
temp.explosion.transform.parent = this.empty.transform;
temp.explosion.transform.position = collision.Gameobject.transform.position;
temp.explosion.transform.scale = v3(1,1,1);

temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
for (temp.col: temp.affected) {
if (temp.col.GetComponent(Type::RigidBody)!= NULL) {
temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
}
}

if (collision.Gameobject.name == "assets/jimmyminigame/robot.prefab(CLONE)") {
this.wreckedrobot = Object::Instantiate(Type::GameObject, this.wreckedrobotprefab);
this.wreckedrobot.transform.parent = this.empty.transform;
this.wreckedrobot.transform.position = collision.Gameobject.transform.position;;
Object::Destroy(collision.Gameobject);
}

if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;

Object::Destroy(gameobject);
}

==== New: Adding Explosion Force ====
Upon Collision, we instantiate and place the explosion. To make it seem more realistic we add an explosion force.

We first gather the Colliders around the area of explosion with a radius of 5;
{| class="wikitable"
!temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
|}
this will return a list of colliders in the sphere area around the explosion.

We then make sure they have a Rigid Body component and apply explosion force to them;
{| class="wikitable"
!temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
|}
In this conditional block we ignore the collision if it is between two projectiles;
{| class="wikitable"
!if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;
|}
function destroy() {
this.start = false;
echo("destroy");
Object::Destroy(this.turret);
Object::Destroy(this.launcher);
Object::Destroy(this.robot1);
Object::Destroy(this.robot2);
Object::Destroy(this.empty);
}

==== New : Destroying GameObjects ====
Here when the player says "dest"; this function is called and
{| class="wikitable"
!Object::Destroy(gameobject);
|}
is used to destroy the GameObject.

We can use this function with an added parameter that indicates the time in seconds to wait before destroying the GameObject;
{| class="wikitable"
!Object::Destroy(gameobject, seconds);
|}

Placing GameObjects in NPC

2021-10-12T11:55:37Z

JimmyAkl:

Another way to make GameObjects visible to all the Players is by placing them in NPCs.

However, placing many NPCs may be heavy on the server, so beware of that whenever you're doing so.

Start off by creating the NPC the normal way:

Create a Script file in classes. You load the assets the same it was done before in weapons; under '''//#CLIENTSIDE'''
[[File:3d samples documentation test.png|none|thumb|1040x1040px]]
function onPlayerChats() {
if (player.chat == "/destroy") this.destroy();
}

//#CLIENTSIDE

function onCreated() {
(@"3D/Dev/AssetManager").loadAssetBundle("documentationexample");
this.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
this.bomb = Object::Instantiate(Type::GameObject, this.prefab);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localposition = v3(0,0.5,0);
}

'''Class:''' ''3d_samples_documentation_test''

Everything is the same when it comes to loading and instantiating the prefabs.

The only difference is for this line of code:
{| class="wikitable"
!this.projectile.transform.parent = this.gameobject.transform;
|}
Here, '''''this.gameobject''''' is the NPC GameObject. It is an empty GameObject we attach our prefabs to. We create the prefabs and make them children of this NPC GameObject.

===== Destroying the NPC: =====

* '''''this.destroy''''' will destroy the NPC and all the children as well. (''done on'' ''ServerSide'')
* You could also destroy the NPC and its children using the Unity Binding function: '''''Object::Destroy(this.gameobject).''''' (''done on ClientSide'')

Now in your other script/weapon. To place the NPC in the scene, we use '''''putnpc2(x,y,"")''''';

On ClientSide we trigger server in order to place the NPC containing the prefabs, and inform all the other clients of it, by implementing '''''onActionServerSide()'''''.
findplayer("Graal5918039").addweapon(this.name);

function onActionServerside(cmd,x,y) {
if (cmd == "bomb") {
temp.bombernpc = putnpc2(x,y,"");
temp.bombernpc.join("3d_samples_documentation_test");
}
}

//#CLIENTSIDE

function onCreated() {
triggerserver("gui", this.name, "bomb", player.x, player.y);
}
'''Weapon:''' ''3D/Samples/Examples/DocumentationTest''

File:3d samples documentation test.png

2021-10-12T11:54:08Z

JimmyAkl:

placing GO in npcs

Uploading and Loading AssetBundles

2021-10-12T11:49:45Z

JimmyAkl:

Up until now, we have been using PrimitiveTypes for our GameObjects.

In this section, we will start using different GameObjects. I will go over how to upload your assetbundles containing all your customized prefabs to the server. How to load, instantiate, and manipulate them.
===Uploading AssetBundles===
You will need to have Unity installed for this part.

You will also need to have the “Quattro3D- Unity Project for bundle asset creation.7z" Unity project installed from the google drive.

I will be going through an example, demonstrating how it’s done.

Begin by choosing what prefabs you want to upload. In our case, I will upload a bomb and a character prefab, which I already have ready in a different project.

Note: Remember you cant put scripts in your asset bundles.

Open the Unity project downloaded (“Quattro3D- Unity Project for bundle asset creation.7z"). This project contains a script that builds the assetbundles and puts them in the Assets/StreamingAssets folder, which will hold all our uploadable files.

In the Assets folder, I will create a new folder and name it Example.

Next I will import my prefabs;

In the top left menu hit (Assets>Import New Asset/Import Package). Go to the location of your prefabs and select them and press Import.

[[File:Uploading assetbundles.png|frameless|371x371px]]

[[File:Prefabs.png|frameless|476x476px]]

[[File:Imported prefabs.png|frameless|773x773px]]

Now that we’ve imported our assets, we’ll create an assetbundle to be uploaded to the server;

Using the Unity way of creating assetbundles by flagging the prefabs:

Select all the prefabs in the asset folder, the Inspector Window should open. At the bottom right of your screen, in the Inspector Window, create or select an existing name for your assetbundle.

The bundle will embed all the assets/prefabs under that flagged directory. You can of course put multiple prefabs/files/subdir...etc inside an asset bundle.

[[File:Adding a tag to the prefabs.png|frameless|541x541px]] [[File:Tagging prefabs.png|frameless|541x541px]]

Now build your asset by pressing on BuildAssetBundles>PackagesBuilder>buildAssetBundles in that project.

The built asset will be stored in the downloaded Unity Project in “Quattro3D- Unity Project for bundle asset creation\Assets\StreamingAssets”

[[File:Uploading assets to the server.png|frameless|712x712px]]

The file that we’ll use to upload to graal should end with “.txt”

[[File:Uploading to the server.png|frameless|800x800px]]

Finally to upload the asset to the server, login on rc, go to levels/assetbundles and drop the “.txt” file there.

It should be automatically downloaded to /Users/”yourusername”/AppData/LocalLow/Graal Worlds/Levels3d/assetbundles[[File:Uploading assets through rc.png|center|frameless|477x477px]]''You’re strongly advised to generate a unitypackage too when you generate an asset bundle and upload it to the server, so that everyone can rebuild the bundle on every platform.''

To view your asset and your prefabs, login to the Client, hit F10 to open the Bundle Explorer and search for your asset name.[[File:Bundle explorer.png|center|frameless|768x768px]]
===ClientSide Loading Assets===
Now to load your prefabs using GraalScript; to your code add the following:

You can use the Bundle Explorer (F10) to copy the path of the AssetBundle.
{| class="wikitable"
|findplayer("Graal5918039").addweapon(this.name);
//#CLIENTSIDE

function onCreated() {

(@"3D/Dev/AssetManager").loadAssetBundle("documentationexample");

}

function onAssetBundleDownloaded(bundlename) {

if (bundlename == "documentationexample") {

player.chat = "example loaded";

temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");

this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);

this.bomb.transform.position = v3(player.x + 5, player.z, player.y);

}

}
|}[[File:Loading prefabs.png|center|frameless|406x406px]]
{| class="wikitable"
!(@"3D/Dev/AssetManager").loadAssetBundle("documentationexample");
|}
The above method loads and downloads the AssetBundle.
{| class="wikitable"
! function onAssetBundleDownloaded(bundlename) {}
|}
And Implementing the '''''onAssetBundleDownloaded''''' will make sure the Assetbundle has been loaded. We could've skipped this step and directly created the prefab, but best is to make sure the Asset has been loaded.

We then create a prefab:
{| class="wikitable"
!temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
|}
instantiate it,
{| class="wikitable"
!this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);
|}
and give it a position in the scene:
{| class="wikitable"
!this.bomb.transform.position = v3(player.x + 5, player.z, player.y);
|}

Getting Started Examples

2021-10-12T11:13:26Z

JimmyAkl:

Here are a few examples for beginners wanting to get into Graal3D. You will need to have both the '''Worlds Client''' and '''RC''' downloaded. You will also need an authorized account to be able to login to the server.
#Download the build compressed file, uncompress it and run the Build application.
#Login with your GraalID and password, a window will open containing Worlds and Account info.
#Login to the erareloaded server by typing “erareloaded” in the bottom left server field and press Enter.

Once logged in, you're required to know how to use the tools that allow you to warp to different levels, debug your code... Unity tools are also available as well.

An explanation of all the tools is available here: [[Tools]]
===Building a Wall Example - ''Creating prefabs and instantiating them''===
This example is found in the Unity Manual; We will build a wall using primitive type Cubes as Gameobjects. It will be demonstrated using Unity C# and on Graal3D using Graalscript.
====Using Unity====
Open the Unity editor with a new project.

'''Step1: Creating an empty Gameobject to hold our Script'''

To your scene add an empty Gameobject. To do that, right click in the Hierarchy Section (on the left) and click on '''Create Empty''', place the created Gameobject in the scene in front of the camera.

This Gameobject will hold our script to build a wall.

[[File:1.png|frameless]]

'''Step2: Creating a Prefab'''

In the same way add a Cube Gameobject to the Hierarchy (right click in Hierarchy -> 3D Object -> Cube).

Now drag the Cube from the Hierarchy to the Assets Section to create a prefab (it will serve as a template to instantiate cubes). Rename the Cube to block (right click on the prefab -> rename).

[[File:2.png|frameless|349x349px]]

'''Step3: Running the script'''

Now to the empty Gameobject we’ll need to add the script that builds a wall.

Press on the Gameobject in the Hierarchy, all its details will pop up in the Inspector Section (on the right). Press on Add Component and search for “script” to add a new script.

[[File:3.png|frameless]]

To modify the script, open it in your IDE and copy the C# script below.

'''Note:''' Make sure you name the public class the same name as your script file.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class wall: MonoBehaviour {
public GameObject block;
public int width = 10;
public int height = 4;
void Start(){
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
Instantiate(block, new Vector3(x, y, 0), Quaternion.identity);
}
}
}
}
''Building a Wall - C# Script''

Finally, you’ll need to add the block prefab that we’ve created earlier to script component (to replace the public Gameobject variable “block” in the script).

To do that, drag it from the assets folder to the script component.

[[File:Prefab.png|frameless]]

After having completed all the steps above, you should be able to start your scene, it will run all the scripts of the Gameobjects... et Voilà! A Wall![[File:WallOnUnity.png|frameless|671x671px]]

''Wall with 10 Columns and 4 Rows''

'''Explanation:'''

A script needs to implement a class that extends the built-in class '''MonoBehavior'''.
{| class="wikitable"
|public class wall: MonoBehaviour { }
|}The '''Start''' function is where you instantiate your Gameobjects.

The '''Update''' function is where the gameplay updates happen (Gameobject movement, triggering actions, taking user input...). It is similar to the onTimeOut / onMouseDown / onKeyPressed... functions in Graalscript.

'''Important Note:'''

[[File:Coordinates.png|frameless]]

Everything related to movement, direction, rotation, speed… in Unity is done using Vectors: '''''new Vector3(x, y, z)'''''

In unity the y axis represents the vertical axis (usually referred to as z)

'''Instantiate Function in Unity:'''
{| class="wikitable"
|Instantiate(block, new Vector3(x, y, 0), Quaternion.identity);
|}'''Instantiate Function in Unity:'''
{| class="wikitable"
|public static Object Instantiate(Object original, Vector3 position, Quaternion rotation);
|}In the example, the Object is the block and the rotation is
{| class="wikitable"
|Quaternion.identity
|}
to indicate 0 rotation.

'''Quaternions:'''

Quaternions are used to represent rotations. The most used Quaternion functions: Quaternion.LookRotation, Quaternion.Angle, Quaternion.Euler, Quaternion.Slerp, Quaternion.FromToRotation, and Quaternion.identity.

'''Another Way:'''

For primitive types there’s no need to actually create a prefab since they are recognized by Unity. We could have skipped step 2 where we create the prefab and modified our code to this:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class wall: MonoBehaviour {
public int width = 10;
public int height = 4;
void Start() {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
GameObject.CreatePrimitive(PrimitiveType.Cube).transform.position = new Vector3(x, y, 0);
}
}
}
}
''Building a Wall - C# Script''
====Using Graal3D====
We are going to mimic the second C# script since it would be useless to upload a Cube prefab to the server, when we can simply instantiate them using PrimitiveType.

The same script above will look like this in GraalScript: ('''''Weapon:''''' ''3D/Samples/Examples/BuildingWall'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated() {
this.width = 10;
this.height = 4;
for (temp.y = 0; temp.y < this.height; ++temp.y) {
for (temp.x = 0; temp.x < this.width; ++temp.x) {
GameObject::CreatePrimitive(PrimitiveType::Cube).transform.position = v3(player.x - 5 + temp.x, temp.y, player.y + 1);
}
}
}
''Building a Wall - Graal Script''

The two codes are almost the same except for:
*The '''''onCreated()''''' function replaces the '''''start()''''' function
*The “ . ” for methods is replaced by “:: ”
'''Function format:''' Unity C#: '''''Type.method''''' => Graal Script: '''''Type::Method'''''
*'''''v3(x,y,z)''''' replaces '''new''' '''''Vector3(x,y,z)'''''
*The Gameobject is instantiated close to the player using (player.x and player.y)
[[File:Wall.png|frameless|695x695px]]

''Wall with 10 Columns and 4 Rows''
===Circle Formation Example - Using Rotation and Mathf functions===
This example is similar to the one above, we’ll instantiate the Cubes in a circular shape with rotation so that they all point towards the player.
====Using Unity====
Just like in the previous example; create a new script file named “CircleFormation”, open it in you editor and copy paste this code:
using UnityEngine;
public class CircleFormation: MonoBehaviour {
public GameObject prefab;
public int numberOfObjects = 20;
public float radius = 5f;
void Start() {
for (int i = 0; i < numberOfObjects; i++) {
float angle = i * Mathf.PI * 2 / numberOfObjects;
float x = Mathf.Cos(angle) * radius;
float z = Mathf.Sin(angle) * radius;
Vector3 pos = transform.position + new Vector3(x, 0, z);
float angleDegrees = -angle*Mathf.Rad2Deg;
Quaternion rot = Quaternion.Euler(0, angleDegrees, 0);
Instantiate(prefab, pos, rot);
}
}
}
''Circle Formation - C# Script''

Create an empty Gameobject in the Hierarchy, add the script to it (as a component).

Add a Cube Gameobject to the Hierarchy (right click -> 3D Object -> Cube).

Now drag the Cube from the Hierarchy to the Assets Section to create a prefab, rename it to “prefab” to be referenced by the script. Finally add it to the script on the Empty Gameobject and hit run.

[[File:Circle formation unity.png|frameless|751x751px]]

'''Explanation:'''

In this example we use the '''Mathf''' collection, a struct containing all the static math methods.

https://docs.unity3d.com/ScriptReference/Mathf.html for all the methods.

We also use the '''''Quaternion.Euler''''' to rotate the cubes. You can rotate around whatever axis you want, in our example '''''Quaternion.Euler(0, angleDegress, 0)''''' rotates the cubes around the y axis.

'''Another Way:'''

Just like before we could’ve just used '''''GameObject.CreatePrimitive(PrimitiveType.Cube)''''' to create the cubes and then change the transform.position and the transform.rotation.
====Using Graal3D====
Again, since we don’t want to upload useless PrimitiveType prefabs to the server, we use this approach: ('''''Weapon:''''' ''3D/Samples/Examples/CircleFormation'')
findplayer("GraalID").addweapon(this.name);
function onCreated() {
temp.nbofobjects = 20;
temp.radius = 5f;
for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
temp.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
temp.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
[[File:Circle formation graal3d.png|frameless|639x639px]]

''Circle Formation - Graal Script''
===Moving Cube Example - Using the Update function===
====Using Unity====
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class MovingCube: MonoBehaviour {
GameObject cube;
public int height = 10;
public float yCenter = 0f;
void Start() {
cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = new Vector3(0, 0f, 0);
}
void Update() {
cube.transform.position = new Vector3(cube.transform.position.x, yCenter + Mathf.PingPong(Time.time * 2, height) - height / 2f, cube.transform.position.z);
}
}
''Moving Cube - C# Script''

Here we use the Update function. As its name suggests, it will serve to update gameplay and move the cube up and down depending on the time.
====Using Graal3D====
('''''Weapon:''''' ''3D/Samples/Examples/MovingCube'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated(){
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.position = v3(player.x,player.z,player.y);
this.height = 10;//max height of Box's movement
this.yCenter = 0.0;
SetTimer(0.001);
}

function onTimeout() {
this.cube.transform.position = v3(this.cube.transform.position.x,this.yCenter + Mathf::PingPong(Time::time *2, this.height) - height / 2.0,this.cube.transform.position.z);
SetTimer(0.001);
}
Moving Cube - GraalScript

Here the '''''SetTimer()''''' and '''''onTimeout()''''' functions replace the '''''Update()''''' function in Unity.
===Cube with Physics - Using Physics and Collision===
In this example we will add physics to our Gameobject, it will be subject to gravity, forces and collisions with other Gameobjects. We will also see how to detect and handle these collisions.

('''''Weapon:''''' ''3D/Samples/Examples/SimplePhysicObject'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated() {
SetTimer(9999);
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.position = v3(player.x + 5, player.z, player.y);
this.cube.AddComponent(Type::RigidBody);
Quattro::EventManager::AddOnCollisionHandlerTo(this.cube, this.cube.layer);
this.catcheventobject(this.cube, "onCollisionEnter", "onCubeCollisionEnter");
}

public function onCubeCollisionEnter(gameobject, collision) {
player.chat = "Collision!";
}
''Cube with Physics - Graal Script''

We create and place a Cube just like the examples before.

To add physics to the GameObject, we add the '''RigidBody Component''';
{| class="wikitable"
!this.cube.AddComponent(Type::RigidBody);
|}
Now to add a Collision Handler;
{| class="wikitable"
!''Quattro::EventManager::AddOnCollisionHandlerTo()''
|}
And
{| class="wikitable"
!''this.catcheventobject(GameObject, “onCollisionEnter”, “onFunctionName”)''
|}
Which will catch collision and call the function '''''onFunctionName()''''' that you have to implement;
public function onCubeCollisionEnter(gameobject, collision) {
player.chat = "Collision!";
}
The two parameters:

'''gameobject:''' it is the Gameobject that was just used to detect collision (''the cube in our example'')

'''collision:''' describes the collider we hit, you can retrieve the GameObject collided with by using: '''''collision.GameObject'''.''

'''Note:''' Whenever we use collisions, the '''''SetTimer(9999)''''' is essential; it will keep the script alive and always checking for events. the Unity function OnUpdate() will be triggered for every frame.

Graal3D Scripting Manual

2021-10-12T11:02:24Z

JimmyAkl: changing worlds client download link

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Worlds Client:''' https://github.com/TOONSLAB/GRAALONLINE/releases

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Graal3D Scripting Manual

2021-10-12T10:42:29Z

JimmyAkl: changing graal3d client with worlds client

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The Worlds Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Worlds Client:''' https://drive.google.com/drive/u/0/folders/1rpOli0fxnA-Q7-IpYg3rUFJ44M0PsSxd

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Unity UI

2021-09-02T18:04:08Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]In this section we will go over an example of making a UI on unity and uploading and coding it on Client3D in graalscript.

'''Unity Part:'''

Open the “Quattro3D- Unity Project for bundle asset creation” folder using unity hub.

To the assets folder, add we add a folder that will hold all the prefabs of the assetbundle.

To the scene, add a Canvas (in the Hierarchy, right click -> UI -> Canvas). The Canvas will hold all the elements of our UI (buttons, text, scrollbar, images…).

Select the Canvas and in the Inspector go to '''Canvas Scaler''' and select '''Scale With Screen''' for '''UI Scale Mode'''. This will allow the canvas Canvas to expand to full screen on all screens.

Now to build the UI you see above (devtools). Start by adding Text elements (right click on Canvas -> UI -> Text).

For each element, change the name and the text according to its function, change the color to white, add a button component and add a animation component. In the '''Rect Transform''' component, in the Anchor Presets, hold Alt and select top left to position your element.

Add all the Text elements and position them (Inspector, Bundle Explorer, Console, Camera, Rendering).

Now, to add the back button. Add an Image element to the UI, change its name to “back”, and in the image component add the source of the image (drop down in our case). Rotate it -90 deg on the Z axis for it to face left. Add a button component to turn it to a back button that closes the devtools.

For the grey background you see, add and image just like before, change its color to black and change the A field in RGBA to 48 to make it transparent. Add an '''Outline''' component and change the '''Effect Color''' to white to add an outline to the image.
[[File:Unity UI.png|none|thumb|1006x1006px]]

Now that we’ve added all our elements to the Canvas, it’s time to create our animations.

To create an animation, in the top menu (next to Files, Edit, Assets…) go to Window -> Animation -> Animation.

The animation tab should open in the bottom. Select the component you want to create an animation for and create and name the animation.

We will be doing the sliding background image example for the animation.

To record the animation, press on the record button. We want the image to slide in. So put the cursor on time 0s, and change the Pos X to -65 (outside of the screen) then move the cursor to 4s and change the Pos X back to 65. Press the record button again to save the recording.
[[File:Unity UI anim.png|none|thumb|1032x1032px]]

You can press play to view your animation in action. To add the animation to the element; simply add an animation component and add the source of the animation you just created.

Same thing goes for all the other animations.

'''Graal Script Part:'''

Now that we’ve created our prefabs and added the animations, our canvas is ready to be uploaded on the server and scripted. Save the AssetBundle and upload it to the server ([[Uploading and Loading AssetBundles]] for more info).
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
SetTimer(9999);
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btnb: this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}
We load the assetbundle the usual way:
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
'''''Settimer(9999);''''' is necessary for the weapon to keep checking for button clicks.

We create and instantiate the canvas prefab.
this.devuiprefab = GameObject::fromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);
this will display the canvas on the client screen.

To detect button clicks;
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
we first find the button GameObject by name ('''this.devui.transform''' being the transform component of the canvas, and '''btn''' is the button name we want to find).

Next, we add an EventManager to the button component of the gameobject we just found ('''temp.btn.gameobject.GetComponent(Type::UI::Button)''').

And '''this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick")''' to catch all the onClick events.

Finally, we implement '''public function onDevToolClick(go)''' to add functionalities after button is pressed (with '''go''' the gameobject being pressed).

For animations, to add or play an animation, you will need to get the animation component of the GameObject first. (using: '''temp.img.gameobject.GetComponent(Type::Animation)''')
temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
(more script functionalities for animations available here: https://docs.unity3d.com/ScriptReference/Animation.html).

Bomberman MiniGame

2021-09-02T17:49:49Z

JimmyAkl:

Welcome to the Bomberman Minigame Tutorial!

= BomberMan =

==== Intro ====
BomberMan is a multiplayer game (usually 4 players). Each player can drop bombs that, upon explosion, destroy the grey pillars making a path to other players. The objective of the game is to eliminate other players with the exploding bombs. Power ups are also sometimes dropped when pillars are destroyed (increase of speed, explosion power and number of bombs allowed to place at a time).
[[File:Bomberman cover.png|none|thumb|675x675px]]
Assets are available on the server under:

'''bombermanprefabs'''

[[File:Bomberman prefabs.png|frameless]]

and '''bombermanlevel1'''

[[File:Bomberman level prefab.png|frameless]]

Since this game is meant to be multiplayer, we will be placing the GameObjects in NPCs for them to be visible to all the players and triggerring the server every time we want to place them. (more info on that here: [[Placing GameObjects in NPC]])

First, we have the weapon that launches the game and places the NPCs (''found under '''weapon: 3D/Samples/BomberMan/Game''''')

We've implemented a graalscript UI (which is not covered in this section, considering you know graalscript) that allows us to launch the game;
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
//temp.pnpc.DropBomb(explvl);
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}

//#CLIENTSIDE
function onCreated() {
echo(this.name @ " OnCreated");
}

public function Load() {
level.explosionpower = 3; //for powerups with explosion
level.numberofbombs = 2; //number of bombs allowed to place at a time
level.speed = 7; //player default speed

echo(this.name @ " LOAD");
Object::destroy(this.bomberManParentNode);
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
new GuiButtonCtrl("bomberman_Quit") {
profile = GuiBlueButtonProfile;
x = 600;
y = 200;
width = 150;
height = 30;
text = "bombermanQuit";
}

temp.warpLevel = "only_ground.nw";
temp.warpX = 4.65;
temp.warpY = 21.33;
temp.warpZ = 0.7;
WARPMANAGER.Warp(temp.warpX, temp.warpY ,temp.warpZ ,temp.warpLevel);
sleep(0.5);
start();
}

function bomberman_Quit.onAction() {
BomberManQuit();
}

public function BomberManQuit() {
if (isObject("bomberman_Quit")) {
"bomberman_Quit".destroy();
}
PLAYERMOVEMENT.UnFreeze();
PLAYERMOVEMENT.canJump = true;
this.GAMEON = false;
}

function start() {
PLAYERMOVEMENT.canJump = false;
this.GAMEON = true;
triggerserver("gui", this.name, "level", -60 , 14);
}

function onKeyPressed(keycode, keychar) {
if (this.GAMEON == true) {
if (keycode == "32, ,57") {
DropBomb();
}
}
}

function DropBomb() {
this.hit = RaycastHit::create();
done = Physics::Raycast(player.gameobject.transform.position, Vector3::Down, this.hit, 100);
//sleep(0.05);
triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}

the '''''Load()''''' function is called when the minigame is launched (Devtools -> Minigames -> BomberMan).

'''level.explosionpower = 3;''' is how much tiles the explosion is going to cover. (at the beginning it's 3)

'''level.numberofbombs = 2;''' is the number of bombs a player is allowed to place at a time. (at the beginning it's 2)

In the function '''''start()''''', we trigger the server with the command "'''level'''" to load the bomberman map by placing an NPC and joining it with the class "'''3d_samples_bomberman_level'''".

Once we start the game, the player is not allowed to Jump: '''PLAYERMOVEMENT.canJump = false;'''

And pressing space will be used to drop a bomb, '''''function onKeyPressed()''''' checks if space is pressed and calls '''''DropBomb()'''.''

==== New: RayCast: ====
Think of RayCast as '''''triggeraction()''''' that triggers NPCs at a given (x,y). Similarly, '''''RayCast''''' casts a ray given a position (origin), a direction and a length, detecting colliders.
{| class="wikitable"
!Raycast(Vector3 origin, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);
|}
'''Returns:''' Boolean indicating if the RayCast hit a Collider.

''(More info here: https://docs.unity3d.com/ScriptReference/Physics.Raycast.html<nowiki/>)''

Here, since the bomberman level is a grid and the floor is made of squares. We want the player to drop the bomb exactly in one square and not in between two. Therefore, when space is pressed, we RayCast with the PlayerGameObject as '''origin''', with a Vector3::Down '''direction''', '''''this.hit''''' as the '''output''' and 100 for '''length'''. The other parameters are kept as default.

This will return the collider of the GameObject underneath the player, which is one square tile.

We extract the tile's position from '''''this.hit''''':
{| class="wikitable"
!this.hit.transform.gameobject.transform.position.x / y
|}
And we trigger the server, with the command "bomb" and the coordinates, to place a bomb NPC;
{| class="wikitable"
!triggerserver("gui", this.name, "bomb", this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
|}
function onActionServerside(cmd, x, y) {
if (cmd == "bomb") {
temp.pnpc = putnpc2(x, y, "");
temp.pnpc.join("merlin_bomberman_bomb");
}
if (cmd == "level") {
temp.bombernpc = putnpc2(x, y, "");
temp.bombernpc.join("merlin_bomberman_level");
}
}
Now, on to the classes!

'''"3d_samples_bomberman_level" Class:'''
function onCreated() {
//Set a 10 minute timer to automatically destroy the levelprefab
scheduleEvent(120, "DestLvl");
}
//Destroy if the server restarts

function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "dest") onDestLvl();
}

function onDestLvl() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
Quattro::AssetManagement::LoadAssetBundle("bombermanlevel1");
}

function onAssetBundleDownloaded(bundlename){
if (bundlename == "bombermanlevel1") {
player.chat = "bombermanlevel loaded";
temp.prefab = GameObject::fromassetbundle("bombermanlevel1", "assets/bombermantest/big level 2.prefab");
this.bomberlevel = Object::Instantiate(Type::GameObject, temp.prefab, this.gameobject.transform, false);
this.bomberlevel.transform.parent = this.gameobject.transform;
this.bomberlevel.transform.localposition = v3(-15,0,0);
this.bomberlevel.transform.localscale = v3(1,1,1);
}
}

function onPlayerChats() {
if (player.chat == "dest") Object::Destroy(this.gameobject);
}
Here we place the level GameObject in an NPC ([[Placing GameObjects in NPC]]) and we only load and instantiate the level the usual way ([[Uploading and Loading AssetBundles]]).

'''"3d_samples_bomberman_bomb" Class:'''
function onCreated() {
//echo("merlin_testbomb");
scheduleEvent(3600, "RemoveBomb");
}

//Destroy if the server restarts
function onInitialized() {
this.destroy();
}

function onPlayerChats() {
if (player.chat == "/destroy") {
onRemoveBomb();
}
}

function onRemoveBomb() {
this.destroy();
}

//#CLIENTSIDE
function onCreated() {
this.dropped = false;
this.powerup = randomstring({"bomb", "explosion", "speed"});

DropBomb();
}

function DropBomb() {
if (level.numberofbombs == 0) return;
--level.numberofbombs;

Quattro::AssetManagement::LoadAssetBundle("bombermanprefabs");
Quattro::AssetManagement::LoadAssetBundle("staffstick");
this.speedprefab = GameObject::fromassetbundle("staffstick","assets/johntest/staffstick_era.prefab");
this.explosionprefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/explosion.prefab");
this.prefab = GameObject::fromassetbundle("bombermanprefabs", "assets/bomberman/prefabs/bomb.prefab");
this.bomb = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localeulerangles = v3(0, 0, 0);
this.bomb.transform.localposition = v3(0, 0.5, 0);

scheduleEvent(3, "Explode");
}

function onExplode() {
echo("onexplode");

echo ("prefab type=" @ this.explosionprefab.objecttype());
this.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
echo ("explosion type=" @ this.explosion.objecttype());
this.explosion.transform.parent = this.gameobject.transform;
this.explosion.transform.localposition = v3(0, 0, 0);
this.explosion.transform.localscale = v3(1,1,1);

Object::Destroy(this.bomb, .3f);

this.exploded = true;

CreateExplosion(Vector3::forward);
CreateExplosion(Vector3::right);
CreateExplosion(Vector3::back);
CreateExplosion(Vector3::left);

++level.numberofbombs;
}

function CreateExplosion(direction) {
for (temp.i = 1; temp.i < level.explosionpower; temp.i++) {
this.hit = RaycastHit::create();
done = Physics::Raycast(this.bomb.transform.position.Add(v3(0,0.5,0)), direction, this.hit, temp.i);

if (!done || this.hit.transform.gameobject.name.starts("assets/bomberman/prefabs/explosion.prefab") || this.hit.transform.gameobject.name.starts("TPlayer")){
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.localposition = v3(0,0,0).Add(direction.Mult(temp.i));
Object::Destroy(temp.explosion, 0.7);
}
if (this.hit.transform.gameobject.name.starts("E_Bomber_Pilar_01_")|| this.hit.transform.gameobject.transform.parent.gameobject.name.starts("E_Bomber_Pilar_01_")) {
if (!this.dropped) {
if (rand(0,1) < 0.2) {
this.dropped = true;
//drop power up
droppowerup(this.hit.transform.gameobject.transform.position.x, this.hit.transform.gameobject.transform.position.z);
}
}
Object::Destroy(this.hit.transform.gameobject.transform.parent.gameobject);
Object::Destroy(this.hit.transform.gameobject);
Object::Destroy(temp.explosion, 0.7);
temp.explosion = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
temp.explosion.transform.position = this.hit.transform.position;
}
}
}

function droppowerup(x,z) {
if (this.powerup == "bomb") {
this.powerupGO = Object::instantiate(Type::GameObject, this.prefab, this.gameobject.transform, false);
}
if (this.powerup == "explosion") {
this.powerupGO = Object::instantiate(Type::GameObject, this.explosionprefab, this.gameobject.transform, false);
}
if (this.powerup == "speed") {
this.powerupGO = Object::instantiate(Type::GameObject, this.speedprefab, this.gameobject.transform, false);
}
this.powerupGO.transform.position = v3(x, 0.5, z);
this.powerupGO.transform.scale = v3(0.5,0.5,0.5);

sphereCollider = this.powerupGO.AddComponent(Type::SphereCollider);
sphereCollider.size = v3(1, 10, 1);
}

public function onActionGrab() {
player.chat = this.powerup;
Object::Destroy(this.gameobject);
if (this.powerup == "bomb") {
++level.numberofbombs;
}
if (this.powerup == "explosion") {
++level.explosionpower;
}
if (this.powerup == "speed") {
PLAYERMOVEMENT.setSpeed(7);
}
}
Again, we are loading and instantiating the prefabs in an NPC.

In '''''function onCreated()''''':

* '''''this.dropped''''' variable is used to allow every bomb to drop only one powerup.
* '''''this.powerup''''' variable is the name of the powerup, chosen randomly each time a bomb is dropped.

'''''DropBomb()''''' is responsible for loading, instantiating and placing the bomb. The player can drop 2 bombs at a time at the start of the game. Therefore, we begin by checking if the player can drop bombs. We decrease the variable '''''level.numberofbombs''''' when a bomb is dropped and decrease it when the bomb explodes.

After positioning the bomb, we schedule event to create the explosion after 3 seconds of placing the bomb;
{| class="wikitable"
!scheduleEvent(3, "Explode");
|}
'''''onExplode()''''' function instantiates an explosion under the bomb;
{| class="wikitable"
!this.explosion.transform.localposition = v3(0, 0, 0);
|}
and calls '''''CreateExplosion(direction);''''' in all the four directions (forward, right, left, back) to instantiate explosions in a cross shape around the bomb.

'''''CreateExplosion(direction)''''' casts a Ray in all the four directions with the given length ('''level.explosionpower'''; the number of tiles it covers) and the bomb as the origin.
{| class="wikitable"
!this.bomb.transform.position.Add(v3(0,0.5,0));
|}we add a '''''Vector3 (0, 0.5, 0)''''' to increase the Y of the '''RayCast''' for it to hit the grey pillars and not the ground.

The two conditional blocks after are used to check if the collider hit by the raycast is a pillar or not.

if it's a Grey Pillar, we destroy it. If not then it's empty space and we instantiate an explosion.

When a Pillar is destroyed, there's a 20% chance it will drop a powerup, by calling the function '''''droppowerup(x,z)''''' with (x,z) the coordinates of the Pillar.

'''''droppowerup(x,z)''''' will check '''''this.powerup''''' and create and place the appropriate GameObject. It also adds a collider Component to be triggered onActionGrab;

==== New: onActionGrab for NPCs: ====
For this to work, the GameObject is required to have a collider.

And '''''public function onActionGrab()''''' needs to be implemented.

Here, we destroy the powerup GameObject and give the player the powerup.

(''weapon: '''3D/Player/Grab''''' for more info)

Plane MiniGame

2021-09-02T17:41:40Z

JimmyAkl:

This minigame is similar to the Car driving minigame. However, we move a plane through obstacles.

'''AssetBundles:''' ''minigameplane - env''

using the bundle explorer (F10):

'''minigameplane:'''

[[File:Plane.png|frameless]]

[[File:Obstacles.png|frameless]]

'''env:'''

[[File:Environment.png|frameless]]

Weapon: '''''3D/Samples/Planeminigame'''''
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onCreated() {
this.keepAlive = true;//SetTimer(9999);
}

function onPlayerChats() {
if (player.chat == "plane") start();
}

public function start() {
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
new GuiWindowCtrl("PlaneMinigame") {
profile = GuiBlueWindowProfile;
x = 120;
y = 0;
width = 670;
height = 340;
text = "Plane Minigame";

new GuiButtonCtrl("Plane") {
profile = GuiBlueButtonProfile;
x = 150;
y = 90;
width = 150;
height = 30;
text = "Spawnplane";
}
new GuiButtonCtrl("Exit") {
profile = GuiBlueButtonProfile;
x = 150;
y = 120;
width = 150;
height = 30;
text = "Exit";
}
}
}

function Plane.onAction() {
exit();
PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANGER.freecam = true;
this.empty = GameObject::Create("empty");
Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
Quattro::AssetManagement::LoadAssetBundle("minigameplane");
Quattro::AssetManagement::LoadAssetBundle("env");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigameplane") {
this.planeprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/small_plane02.prefab");
this.plane = Object::Instantiate(Type::GameObject, this.planeprefab);
this.plane.transform.position = v3(player.x, player.z, player.y);
this.plane.transform.localscale = v3(0.3, 0.3, 0.3);
this.plane.transform.parent = this.empty.transform;

this.RB = this.plane.AddComponent(Type::RigidBody);
this.RB.useGravity = false;

boxCollider = this.plane.AddComponent(Type::BoxCollider);
boxCollider.size = v3(4,4,4);

Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");

this.obstacleprefab = GameObject::fromassetbundle("minigameplane", "assets/drivingplane/vehicles/planes/obstacles 1.prefab");
this.obstacle = Object::Instantiate(Type::GameObject, this.obstacleprefab);
this.obstacle.transform.position = v3(player.x, player.z + 10, player.y + 20);
this.obstacle.transform.localscale = v3(0.3, 0.3, 0.3);
this.obstacle.transform.parent = this.empty.transform;
}
if (bundlename == "env") {
this.envprefab = GameObject::fromassetbundle("env", "assets/jimmyenv2/environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.envprefab);
this.env.transform.position = v3(player.x, player.z + 1.5, player.y);
this.env.transform.parent = this.empty.transform;
}
}

function onUpdate() {
temp.campos = this.plane.transform.position.Add(v3(20,0,0));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

this.verticalInput = Input::GetAxis("Vertical");
this.horizontalInput = Input::GetAxis("Horizontal");

this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));

this.plane.transform.rotate(Vector3::Right.Mult(700 * Time::deltaTime * this.verticalInput));

this.plane.transform.rotate(Vector3::Forward.Mult(700 * Time::deltaTime * this.horizontalInput * -1));

this.propellor = this.plane.transform.Find("Propellor");
this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));
}

public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

function Exit.onAction() {
exit();
}

function exit() {
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.empty);
Input::ResetInputAxes();
}

The function '''''start()''''' creates a UI with two buttons (Spawn Plane and Exit) allowing us to start and end the game.

'''Plane.onAction()''' ''(when the Spawn button is pressed) :''

Calls the '''''exit()''''' function first to destroy GameObjects instantiated before, freezes the player using '''PLAYERMOVEMENT.Freeze();''' ,frees the camera with '''Quattro3D::PlayerCamera::Instance.FreeCam = true;''' and loads all the assets we'll need to use.

In function '''''onAssetBundleDownloaded(bundlename)''''' we catch all the loaded assetbundles, we instantiate the plane, obstacles and environment. And we position them, modify their scales, add components to them and make them a child of an empty GameObject.
{| class="wikitable"
!this.empty = GameObject::Create("empty");
|}
{| class="wikitable"
!this.obstacle.transform.parent = this.empty.transform;
|}
This will help delete all the GameObjects upon deleting the empty GameObject. ('''Object::Destroy(this.empty);''')

Now, the '''''onUpdate()''''' function checks for updates on every frame. '''''SetTimer(9999)''''' needs to be added for it to work.

This function will be responsible for moving the plane, moving the camera following the plane and turning the propeller of the plane.

First for the Camera, we want it to be looking side ways at the plane. We take the plane's position and add to the X axis:
{| class="wikitable"
!temp.campos = this.plane.transform.position.Add(v3(20,0,0));
|}
then we change the camera position to '''''temp.campos;'''''
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;
|}
We'll also need to change the rotation of the camera since it's initially facing forward and we want it to face the plane;
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.rotation = Quaternion::euler(0, -90, 0);
|}
Now, for the movement of the plane. It will be moving forward at a constant speed; '''''this.plane.transform.translate(Vector3::forward.Mult(Time::deltaTime * 5));'''''

And the '''''Input::GetAxis()''''' will help us move it up/down and sideways.

We also find the propellor of the plane and move it at a constant rotation speed;

'''''this.propellor = this.plane.transform.Find("Propellor");'''''

'''''this.propellor.transform.rotate(Vector3::Forward.Mult(1700 * Time::deltaTime));'''''

Finally, the function '''''exit()''''' switches back to the default camera: '''''findweapon("3D/Dev/ToolBar/Camera").cam1();'''''

unfreezes the Player, destroys the GameObjects and resets the Input Axes using: '''''Input::ResetInputAxes();'''''
[[File:Planeminigame gameplay.png|center|thumb|1108x1108px]]You can also add collision detection to the plane to turn it into an actual game.
Quattro::EventManager::AddOnCollisionHandlerTo(this.plane, this.plane.layer);
this.catcheventobject(this.plane, "onCollisionEnter", "onPlaneCollisionEnter");
and implement the function:
public function onPlaneCollisionEnter(gameobject, collision) {
player.chat = "BOOM YOU LOST!";
exit();
}

Driving MiniGame

2021-09-02T17:39:51Z

JimmyAkl:

Welcome to the Driving MiniGame tutorial.

= Intro =

==== DrivingMiniGame ====
This is a simple and easy car driving example. In the assetbundle, there's an environment that we load and instantiate and multiple cars that we can spawn. This game is not focused on the actual driving experience itself, but more on introducing new Unity functionalities.

'''Asset Bundles: ''minigame2, env'''''

using the bundle explorer (F10):

'''minigame2:'''

[[File:Minigame2.png|frameless]]

'''env:'''

[[File:Minigame2 env.png|frameless]]

Weapon: '''''3D/Samples/Drivingminigame'''''
findplayer("GraalID").addweapon(this.name);
this.join("3d_merlin_camera");

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "dest") dest();
if (player.chat == "drive") drive();
}

function drive() {
destLevelName = "only_ground.nw";
x = 19;
y = 10;
z = 0.7;//0.7;
WARPMANAGER.Warp(x, y ,z ,destLevelName);

sleep(1);

new GuiWindowCtrl("MyGUI_Minigame_Window1") {
profile = GuiBlueWindowProfile;
style = $pref::Video::defaultguistyle;
clientrelative = true;
clientextent = "320,240";

canmove = true;
canresize = true;
closequery = false;
destroyonhide = false;
text = "Window 1";
x = 490;
y = 242;

new GuiButtonCtrl("MyGUI_Minigame_Button1") {
profile = GuiBlueButtonProfile;
text = "Car";
width = 80;
x = 77;
y = 31;
}
new GuiButtonCtrl("MyGUI_Minigame_Button2") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Bus";
width = 80;
x = 77;
y = 69;
}
new GuiButtonCtrl("MyGUI_Minigame_Button3") {
profile = GuiBlueButtonProfile;
height = 31;
text = "Quit";
width = 80;
x = 78;
y = 109;
}
new GuiTextCtrl("MyGUI_Minigame_Text1") {
profile = GuiBlueTextProfile;
height = 20;
text = "Select Type:";
width = 71;
x = 11;
y = 5;
}
}
}

function MyGUI_Minigame_Button1.onAction() {
// Button "Car" has been pressed
Quattro::AssetManagement::LoadAssetBundle("minigame2");
Quattro::AssetManagement::LoadAssetBundle("env");
this.vehicle = "car";
}

function MyGUI_Minigame_Button2.onAction() {
// Button "Bus" has been pressed
Quattro::AssetManagement::LoadAssetBundle("minigame2");
Quattro::AssetManagement::LoadAssetBundle("env");
this.vehicle = "bus";
}

function MyGUI_Minigame_Button3.onAction() {
dest();
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "env") {
this.env = GameObject::fromassetbundle("env", "assets/jimmyenv2/Environment.prefab");
this.env = Object::Instantiate(Type::GameObject, this.env);
this.env.transform.position = v3(player.x, player.z, player.y);
}
if (bundlename == "minigame2") {
if (this.vehicle == "bus") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Bus_Blue_Z.prefab");
}

if (this.vehicle == "car") {
dest();
this.vh = GameObject::fromassetbundle("minigame2", "assets/jimmyminigame2/Veh_Car_Blue_Z.prefab");
}

this.vh = Object::Instantiate(Type::GameObject, this.vh);
this.vh.transform.position = v3(player.x - 2, player.z, player.y - 5);
this.vh.AddComponent(Type::RigidBody);

PLAYERMOVEMENT.Freeze();
//Quattro3D::PlayerCamera::Instance.FreeCam = true;
CAMERAMANAGER.freecam = true;
handleMovement();
}
}

function handleMovement() {
this.on = true;
SetTimer(0.05);
this.speed = 20;
this.rotation = 400;
}

function onFixedUpdate() {
this.vInput = Input::GetAxis("Vertical");
this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

this.hInput = Input::GetAxis("Horizontal");
this.vh.transform.Rotate(Vector3::up.Mult(Time::deltaTime * this.rotation * this.hInput * this.vInput));
}

function onTimeOut() {
if(this.on) {
temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
Quattro3D::PlayerCamera::Instance.transform.position = temp.campos;

//this.vInput = Input::GetAxis("Vertical");

//this.hInput = Input::GetAxis("Horizontal");
//if (this.vInput < 0) this.hInput = - Input::GetAxis("Horizontal");

//this.vh.transform.Translate(Vector3::forward.Mult(Time::deltaTime * this.speed * this.vInput));

SetTimer(0.05);
}
}

function dest() {
this.on = false;
findweapon("3D/Dev/ToolBar/Camera").cam1();
PLAYERMOVEMENT.unfreeze();
Object::Destroy(this.vh);
Object::Destroy(this.env);
}

Here we create a UI for the player to choose what vehicle to choose, and we load and instantiate the prefab based on the choice.

==== New: Camera ====
The Camera is the point of view. Here we want the Camera to follow the car while driving and not the player.

In '''''function onAssetBundleDownloaded(bundlename)''''' We use:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.FreeCam = true;
|}
To free the camera. This will free it from following the player GameObject.

Then in '''''function onTimeOut()''''' we want the camera position to be updated with the vehicle's position.

'''''temp.campos''''' is the variable we store the camera's position in. We want it to be behind and above the vehicle for a good view. This is why we get the vehicle's position and add a Vector3 to it:
{| class="wikitable"
!temp.campos = this.vh.transform.position.Add(v3(0,10,-7));
|}
now:
{| class="wikitable"
!Quattro3D::PlayerCamera::Instance.transform.position
|}
allows us to the get the Camera GameObject and to access its transform component and change its position.

We have implemented default cameras found in Weapon: '''''3D/Dev/ToolBar/Camera'''''

We access them through the Weapon "'''''3D/Dev/ToolBar/Camera'''''" using:
{| class="wikitable"
!''findweapon("3D/Dev/ToolBar/Camera").cam1();''
|}and we call the function '''''cam1();''''' in '''''function dest()''''' to go back to the default cam.

==== New: Unity Input ====
{| class="wikitable"
!Input::GetAxis("Vertical");
|}
"Vertical" / "Horizontal"

It checks the arrows pressed and gives a value in the range of (-1 to 1) -1 indicating "down", 1 "up" and 0 "neutral".

We use it here to translate and rotate the vehicle.

Turret MiniGame

2021-09-02T17:35:12Z

JimmyAkl:

Welcome to the Turret Minigame!

In this Tutorial, we will build a turret that rotates and shoots targets around it. The Assets are available on the server.

==== TurretMiniGame GameObjects ====
All the prefabs are under the asset bundle: '''minigame''' (you can view them in the bundle explorer "F10")

Turret that shoots the projectiles:

[[File:Turret.png|frameless|407x407px]]

Robot that will serve as a target:

[[File:Robot Obstacle Minigame.png|frameless|407x407px]]

Cubes Instantiated in different position also for targets:

[[File:Turret Minigame targets.png|frameless|405x405px]]

findplayer("GraalID").addweapon(this.name);

//#CLIENTSIDE
function onPlayerChats() {
if (player.chat == "start") {
destroy();
start();
}
if (player.chat == "dest") destroy();
}
The way I start the minigame is '''onPlayerChats'''; when the player says "start". We'll also see how to '''destroy the GameObjects''' when the player says "dest".
function start() {
this.start = true;
//PLAYERMOVEMENT.Freeze();

//for turret control
this.rotateangle = 0; //Rotation angle of the turret
this.rotateangleB = 270; //Rotation angle of the barrel
this.speed = 15;

this.currentX = player.x;
this.currentY = player.y;
this.currentZ = player.z;
echo ("TurretMiniGame warp from=" @ this.currentLevel @ " x=" @ this.currentX @ " y=" @ this.currentY @ " z=" @ this.currentZ);
WARPMANAGER.Warp(19, 14 ,0.7 ,"only_ground.nw");
sleep(1.5);

Quattro::AssetManagement::LoadAssetBundle("minigame"); //loading the assetbundle
}
'''''this.start = true;''''' will be used to indicate that the game has started.

==== New: Using PLAYERMOVEMENT and WARPMANAGER ====
'''PLAYERMOVEMENT.Freeze()''' is a method that freezes the player (weapon: '''3D/Player/Core/Movement)'''

'''WARPMANAGER.Warp(x,y,z,level)''' (weapon: '''3D/Player/Core/Warp/Manager''')

Having uploaded the Asset bundle called "'''minigame'''" that contains the prefabs to the server, I start off by loading them, creating the prefabs, instantiating them and giving them a position in the '''start function''' ([[Uploading and Loading AssetBundles|Uploading and Loading AssetBundles]] for info on how to upload assets).
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "minigame") {
SetTimer(9999);
this.empty = GameObject::Create("empty"); // for parenting and deleting

this.turret = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/turret.prefab");
this.robot1 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.robot2 = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot.prefab");
this.wreckedrobotprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/robot wrecked.prefab");
this.projectileprefab = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/projectile.prefab");
this.explosion = GameObject::fromassetbundle("minigame", "assets/jimmyminigame/explosion.prefab");

this.turret = Object::Instantiate(Type::GameObject, this.turret);
this.robot1 = Object::Instantiate(Type::GameObject, this.robot1);
this.robot2 = Object::Instantiate(Type::GameObject, this.robot2);

this.turret.transform.position = v3(player.x, player.z, player.y);
this.robot1.transform.position = v3(player.x - 5, player.z - 1, player.y + 10);
this.robot2.transform.position = v3(player.x + 5, player.z - 1, player.y + 10);

this.turret.transform.localscale = v3(1,1,1);
this.robot1.transform.localscale = v3(1,1,1);
this.robot2.transform.localscale = v3(1,1,1);

loadCubes();

player.charactercontroller.enabled = false;
player.gameobject.transform.position = v3(player.x, player.z+5, player.y);

this.launcher = GameObject::Find("Launcher");
this.barrel = GameObject::Find("Barrel");
}
}

function loadCubes() {
temp.width = 10;
temp.height = 4;

for (temp.y = 0; temp.y < temp.height; ++temp.y) {
for (temp.x = 0; temp.x < temp.width; ++temp.x) {
temp.block = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.block.Name = "myblock";
temp.block.transform.parent = this.empty.transform; // for deleting
temp.block.transform.position = v3(player.x - 5 + temp.x, player.z + temp.y, player.y + 15);
temp.block.AddComponent(Type::RigidBody);
temp.block.layer = this.projectile.layer;
}
}

temp.nbofobjects = 20;
temp.radius = 7f;

for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.parent = this.empty.transform;
this.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
this.cube.AddComponent(Type::RigidBody);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
this.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
In the '''''loadCubes()''''' function we instantiate primitive type cubes and position them to build a wall and a circular formation around the turret.

==== New: Moving the Player GameObject ====
The player is a GameObject, and its accessed by:
{| class="wikitable"
!player.gameobject
|}
Before changing the player's transform, the '''''player.charactercontroller''''' must be disabled:
{| class="wikitable"
!player.charactercontroller.enabled = false;
|}
Then we can change the position accessing the transform component of the GameObject:
{| class="wikitable"
!player.gameobject.transform.position = Vector3::Create(player.x, player.z+5, player.y);
|}

==== New: Parenting ====
In Unity, parenting is when a GameObject becomes a parent of another GameObject. The child GameObject will perform all it's transform changes in respect to the parent GameObject and not the Camera. Additionally, deleting the parent GameObject will delete all its children.

We use it for the latter. We create the '''Empty GameObject''', which will serve as a parent for the Cubes ''(children)'' in order to delete them all, since we don't have a reference to each and every cube.

==== New: Finding GameObjects by Name ====
{| class="wikitable"
!GameObject::Find("name")
|}
We use it to find the barrel that we'll move up and down and the launcher that shoots the projectiles.

Now to move the Turret;
function onKeyPressed(keycode) {
if (keycode == "90") { // Z
this.rotateangle -= 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "67") { // C
this.rotateangle += 4;
this.turret.transform.rotation = Quaternion::euler(0, this.rotateangle, 0);
}

if (keycode == "87") { // W
this.rotateangleB = this.rotateangleB < 300? this.rotateangleB + 4: 300;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "83") { // S
this.rotateangleB = this.rotateangleB > 258? this.rotateangleB - 4: 258;
this.barrel.transform.LocalRotation = Quaternion::euler(this.rotateangleB, 0, 0);
}

if (keycode == "32, ,57") { // Space
if (this.start) {
shoot();
}
}
}
We rotate the barrel around the X axis for it to go up and down;
{| class="wikitable"
!Quaternion::euler(this.rotateangleB, 0, 0);
|}
And rotate the turret around the Y axis (Vertical axis);
{| class="wikitable"
!Quaternion::euler(0, this.rotateangle, 0);
|}
this.rotateangle for both cases starts at the initial rotation of the GameObjects and is incremented/decremented based on the direction of the rotation.

In the last conditional block, if space is pressed and if the Game is on ('''''this.start == true'''''), the projectile is shot. Here's how it's done;
function shoot() {
SetTimer(9999);
this.projectile = Object::Instantiate(Type::GameObject, this.projectileprefab);
this.projectile.transform.parent = this.empty.transform;
this.projectile.transform.position = this.launcher.transform.position;
this.projectile.transform.scale = v3(1,1,1);

temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);

Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
}
The projectile is initialized and positioned on the launcher.

We'll need to use physics to shoot the projectile, this is why we get the RigidBody component of the GameObject;
{| class="wikitable"
!temp.rigidBody = this.projectile.GetComponent(Type::RigidBody);
|}
(if the GameObject doesn't have a RigidBody by default, you'll need to add it using: '''''gameobject.AddComponent(Type::RigidBody);''''')

We then add velocity (which is a vector that represents speed in a certain direction). The direction is the Launcher's forward direction, it is multiplied by the desired speed;
{| class="wikitable"
!temp.rigidBody.velocity = this.launcher.transform.forward.Mult(this.speed);
|}
Now to detect collision, we make sure we '''''SetTimer(9999)''''' for the script to stay up and looking for events, we add the Collision Handler to the projectile;
{| class="wikitable"
!Quattro::EventManager::AddOnCollisionHandlerTo(this.projectile, this.projectile.layer);
|}
and we wait for collisions;
{| class="wikitable"
!this.catcheventobject(this.projectile, "onCollisionEnter", "onProjectileCollisionEnter");
|}
public function onProjectileCollisionEnter(gameobject, collision) {
temp.radius = 4;
temp.force = 5;

player.chat = "boom=" @ collision.Gameobject.name;
echo ("collision.Gameobject.name=" @ collision.Gameobject.name);

temp.explosion = Object::Instantiate(Type::GameObject, this.explosion);
temp.explosion.transform.parent = this.empty.transform;
temp.explosion.transform.position = collision.Gameobject.transform.position;
temp.explosion.transform.scale = v3(1,1,1);

temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
for (temp.col: temp.affected) {
if (temp.col.GetComponent(Type::RigidBody)!= NULL) {
temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
}
}

if (collision.Gameobject.name == "assets/jimmyminigame/robot.prefab(CLONE)") {
this.wreckedrobot = Object::Instantiate(Type::GameObject, this.wreckedrobotprefab);
this.wreckedrobot.transform.parent = this.empty.transform;
this.wreckedrobot.transform.position = collision.Gameobject.transform.position;;
Object::Destroy(collision.Gameobject);
}

if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;

Object::Destroy(gameobject);
}

==== New: Adding Explosion Force ====
Upon Collision, we instantiate and place the explosion. To make it seem more realistic we add an explosion force.

We first gather the Colliders around the area of explosion with a radius of 5;
{| class="wikitable"
!temp.affected = Physics::OverlapSphere(temp.explosion.transform.position, 5);
|}
this will return a list of colliders in the sphere area around the explosion.

We then make sure they have a Rigid Body component and apply explosion force to them;
{| class="wikitable"
!temp.col.GetComponent(Type::RigidBody).AddExplosionForce(temp.force, temp.explosion.transform.position, temp.radius, temp.force * 0.5f, ForceMode::Impulse);
|}
In this conditional block we ignore the collision if it is between two projectiles;
{| class="wikitable"
!if (collision.Gameobject.name.starts("assets/jimmyminigame/projectile.prefab")) return;
|}
function destroy() {
this.start = false;
echo("destroy");
Object::Destroy(this.turret);
Object::Destroy(this.launcher);
Object::Destroy(this.robot1);
Object::Destroy(this.robot2);
Object::Destroy(this.empty);
}

==== New : Destroying GameObjects ====
Here when the player says "dest"; this function is called and
{| class="wikitable"
!Object::Destroy(gameobject);
|}
is used to destroy the GameObject.

We can use this function with an added parameter that indicates the time in seconds to wait before destroying the GameObject;
{| class="wikitable"
!Object::Destroy(gameobject, seconds);
|}

Getting Started Examples

2021-09-02T17:31:41Z

JimmyAkl:

Here are a few examples for beginners wanting to get into Graal3D. You will need to have both the '''Graal3D Client''' and '''RC''' downloaded. You will also need an authorized account to be able to login to the server.
#Download the build compressed file, uncompress it and run the Build application.
#Login with your GraalID and password, a window will open containing Worlds and Account info.
#Login to the erareloaded server by typing “erareloaded” in the bottom left server field and press Enter.

Once logged in, you're required to know how to use the tools that allow you to warp to different levels, debug your code... Unity tools are also available as well.

An explanation of all the tools is available here: [[Tools]]
===Building a Wall Example - ''Creating prefabs and instantiating them''===
This example is found in the Unity Manual; We will build a wall using primitive type Cubes as Gameobjects. It will be demonstrated using Unity C# and on Graal3D using Graalscript.
====Using Unity====
Open the Unity editor with a new project.

'''Step1: Creating an empty Gameobject to hold our Script'''

To your scene add an empty Gameobject. To do that, right click in the Hierarchy Section (on the left) and click on '''Create Empty''', place the created Gameobject in the scene in front of the camera.

This Gameobject will hold our script to build a wall.

[[File:1.png|frameless]]

'''Step2: Creating a Prefab'''

In the same way add a Cube Gameobject to the Hierarchy (right click in Hierarchy -> 3D Object -> Cube).

Now drag the Cube from the Hierarchy to the Assets Section to create a prefab (it will serve as a template to instantiate cubes). Rename the Cube to block (right click on the prefab -> rename).

[[File:2.png|frameless|349x349px]]

'''Step3: Running the script'''

Now to the empty Gameobject we’ll need to add the script that builds a wall.

Press on the Gameobject in the Hierarchy, all its details will pop up in the Inspector Section (on the right). Press on Add Component and search for “script” to add a new script.

[[File:3.png|frameless]]

To modify the script, open it in your IDE and copy the C# script below.

'''Note:''' Make sure you name the public class the same name as your script file.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class wall: MonoBehaviour {
public GameObject block;
public int width = 10;
public int height = 4;
void Start(){
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
Instantiate(block, new Vector3(x, y, 0), Quaternion.identity);
}
}
}
}
''Building a Wall - C# Script''

Finally, you’ll need to add the block prefab that we’ve created earlier to script component (to replace the public Gameobject variable “block” in the script).

To do that, drag it from the assets folder to the script component.

[[File:Prefab.png|frameless]]

After having completed all the steps above, you should be able to start your scene, it will run all the scripts of the Gameobjects... et Voilà! A Wall![[File:WallOnUnity.png|frameless|671x671px]]

''Wall with 10 Columns and 4 Rows''

'''Explanation:'''

A script needs to implement a class that extends the built-in class '''MonoBehavior'''.
{| class="wikitable"
|public class wall: MonoBehaviour { }
|}The '''Start''' function is where you instantiate your Gameobjects.

The '''Update''' function is where the gameplay updates happen (Gameobject movement, triggering actions, taking user input...). It is similar to the onTimeOut / onMouseDown / onKeyPressed... functions in Graalscript.

'''Important Note:'''

[[File:Coordinates.png|frameless]]

Everything related to movement, direction, rotation, speed… in Unity is done using Vectors: '''''new Vector3(x, y, z)'''''

In unity the y axis represents the vertical axis (usually referred to as z)

'''Instantiate Function in Unity:'''
{| class="wikitable"
|Instantiate(block, new Vector3(x, y, 0), Quaternion.identity);
|}'''Instantiate Function in Unity:'''
{| class="wikitable"
|public static Object Instantiate(Object original, Vector3 position, Quaternion rotation);
|}In the example, the Object is the block and the rotation is
{| class="wikitable"
|Quaternion.identity
|}
to indicate 0 rotation.

'''Quaternions:'''

Quaternions are used to represent rotations. The most used Quaternion functions: Quaternion.LookRotation, Quaternion.Angle, Quaternion.Euler, Quaternion.Slerp, Quaternion.FromToRotation, and Quaternion.identity.

'''Another Way:'''

For primitive types there’s no need to actually create a prefab since they are recognized by Unity. We could have skipped step 2 where we create the prefab and modified our code to this:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class wall: MonoBehaviour {
public int width = 10;
public int height = 4;
void Start() {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
GameObject.CreatePrimitive(PrimitiveType.Cube).transform.position = new Vector3(x, y, 0);
}
}
}
}
''Building a Wall - C# Script''
====Using Graal3D====
We are going to mimic the second C# script since it would be useless to upload a Cube prefab to the server, when we can simply instantiate them using PrimitiveType.

The same script above will look like this in GraalScript: ('''''Weapon:''''' ''3D/Samples/Examples/BuildingWall'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated() {
this.width = 10;
this.height = 4;
for (temp.y = 0; temp.y < this.height; ++temp.y) {
for (temp.x = 0; temp.x < this.width; ++temp.x) {
GameObject::CreatePrimitive(PrimitiveType::Cube).transform.position = v3(player.x - 5 + temp.x, temp.y, player.y + 1);
}
}
}
''Building a Wall - Graal Script''

The two codes are almost the same except for:
*The '''''onCreated()''''' function replaces the '''''start()''''' function
*The “ . ” for methods is replaced by “:: ”
'''Function format:''' Unity C#: '''''Type.method''''' => Graal Script: '''''Type::Method'''''
*'''''v3(x,y,z)''''' replaces '''new''' '''''Vector3(x,y,z)'''''
*The Gameobject is instantiated close to the player using (player.x and player.y)
[[File:Wall.png|frameless|695x695px]]

''Wall with 10 Columns and 4 Rows''
===Circle Formation Example - Using Rotation and Mathf functions===
This example is similar to the one above, we’ll instantiate the Cubes in a circular shape with rotation so that they all point towards the player.
====Using Unity====
Just like in the previous example; create a new script file named “CircleFormation”, open it in you editor and copy paste this code:
using UnityEngine;
public class CircleFormation: MonoBehaviour {
public GameObject prefab;
public int numberOfObjects = 20;
public float radius = 5f;
void Start() {
for (int i = 0; i < numberOfObjects; i++) {
float angle = i * Mathf.PI * 2 / numberOfObjects;
float x = Mathf.Cos(angle) * radius;
float z = Mathf.Sin(angle) * radius;
Vector3 pos = transform.position + new Vector3(x, 0, z);
float angleDegrees = -angle*Mathf.Rad2Deg;
Quaternion rot = Quaternion.Euler(0, angleDegrees, 0);
Instantiate(prefab, pos, rot);
}
}
}
''Circle Formation - C# Script''

Create an empty Gameobject in the Hierarchy, add the script to it (as a component).

Add a Cube Gameobject to the Hierarchy (right click -> 3D Object -> Cube).

Now drag the Cube from the Hierarchy to the Assets Section to create a prefab, rename it to “prefab” to be referenced by the script. Finally add it to the script on the Empty Gameobject and hit run.

[[File:Circle formation unity.png|frameless|751x751px]]

'''Explanation:'''

In this example we use the '''Mathf''' collection, a struct containing all the static math methods.

https://docs.unity3d.com/ScriptReference/Mathf.html for all the methods.

We also use the '''''Quaternion.Euler''''' to rotate the cubes. You can rotate around whatever axis you want, in our example '''''Quaternion.Euler(0, angleDegress, 0)''''' rotates the cubes around the y axis.

'''Another Way:'''

Just like before we could’ve just used '''''GameObject.CreatePrimitive(PrimitiveType.Cube)''''' to create the cubes and then change the transform.position and the transform.rotation.
====Using Graal3D====
Again, since we don’t want to upload useless PrimitiveType prefabs to the server, we use this approach: ('''''Weapon:''''' ''3D/Samples/Examples/CircleFormation'')
findplayer("GraalID").addweapon(this.name);
function onCreated() {
temp.nbofobjects = 20;
temp.radius = 5f;
for (temp.i = 0; temp.i < temp.nbofobjects; ++temp.i) {
temp.angle = temp.i * Mathf::PI * 2 / temp.nbofobjects;
temp.x1 = cos(temp.angle) * temp.radius;
temp.y1 = sin(temp.angle) * temp.radius;
temp.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
temp.cube.transform.position = v3(player.x + temp.x1, player.z, player.y + temp.y1);
temp.angleDegrees = -temp.angle * Mathf::Rad2Deg;
temp.cube.transform.rotation = Quaternion::euler(0, temp.angleDegrees, 0);
}
}
[[File:Circle formation graal3d.png|frameless|639x639px]]

''Circle Formation - Graal Script''
===Moving Cube Example - Using the Update function===
====Using Unity====
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class MovingCube: MonoBehaviour {
GameObject cube;
public int height = 10;
public float yCenter = 0f;
void Start() {
cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = new Vector3(0, 0f, 0);
}
void Update() {
cube.transform.position = new Vector3(cube.transform.position.x, yCenter + Mathf.PingPong(Time.time * 2, height) - height / 2f, cube.transform.position.z);
}
}
''Moving Cube - C# Script''

Here we use the Update function. As its name suggests, it will serve to update gameplay and move the cube up and down depending on the time.
====Using Graal3D====
('''''Weapon:''''' ''3D/Samples/Examples/MovingCube'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated(){
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.position = v3(player.x,player.z,player.y);
this.height = 10;//max height of Box's movement
this.yCenter = 0.0;
SetTimer(0.001);
}

function onTimeout() {
this.cube.transform.position = v3(this.cube.transform.position.x,this.yCenter + Mathf::PingPong(Time::time *2, this.height) - height / 2.0,this.cube.transform.position.z);
SetTimer(0.001);
}
Moving Cube - GraalScript

Here the '''''SetTimer()''''' and '''''onTimeout()''''' functions replace the '''''Update()''''' function in Unity.
===Cube with Physics - Using Physics and Collision===
In this example we will add physics to our Gameobject, it will be subject to gravity, forces and collisions with other Gameobjects. We will also see how to detect and handle these collisions.

('''''Weapon:''''' ''3D/Samples/Examples/SimplePhysicObject'')
findplayer("GraalID").addweapon(this.name);
//#CLIENTSIDE
function onCreated() {
SetTimer(9999);
this.cube = GameObject::CreatePrimitive(PrimitiveType::Cube);
this.cube.transform.position = v3(player.x + 5, player.z, player.y);
this.cube.AddComponent(Type::RigidBody);
Quattro::EventManager::AddOnCollisionHandlerTo(this.cube, this.cube.layer);
this.catcheventobject(this.cube, "onCollisionEnter", "onCubeCollisionEnter");
}

public function onCubeCollisionEnter(gameobject, collision) {
player.chat = "Collision!";
}
''Cube with Physics - Graal Script''

We create and place a Cube just like the examples before.

To add physics to the GameObject, we add the '''RigidBody Component''';
{| class="wikitable"
!this.cube.AddComponent(Type::RigidBody);
|}
Now to add a Collision Handler;
{| class="wikitable"
!''Quattro::EventManager::AddOnCollisionHandlerTo()''
|}
And
{| class="wikitable"
!''this.catcheventobject(GameObject, “onCollisionEnter”, “onFunctionName”)''
|}
Which will catch collision and call the function '''''onFunctionName()''''' that you have to implement;
public function onCubeCollisionEnter(gameobject, collision) {
player.chat = "Collision!";
}
The two parameters:

'''gameobject:''' it is the Gameobject that was just used to detect collision (''the cube in our example'')

'''collision:''' describes the collider we hit, you can retrieve the GameObject collided with by using: '''''collision.GameObject'''.''

'''Note:''' Whenever we use collisions, the '''''SetTimer(9999)''''' is essential; it will keep the script alive and always checking for events. the Unity function OnUpdate() will be triggered for every frame.

Graal3D Scripting Manual

2021-09-02T17:27:04Z

JimmyAkl: removed johns system

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The 3D Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Graal3D Client:''' https://drive.google.com/drive/u/0/folders/1rpOli0fxnA-Q7-IpYg3rUFJ44M0PsSxd

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Placing GameObjects in NPC

2021-09-02T17:22:53Z

JimmyAkl:

Another way to make GameObjects visible to all the Players is by placing them in NPCs.

However, placing many NPCs may be heavy on the server, so beware of that whenever you're doing so.

Start off by creating the NPC the normal way:

Create a Script file in classes. You load the assets the same it was done before in weapons; under '''//#CLIENTSIDE'''
[[File:NPC GO.png|none|thumb|1041x1041px]]
function onPlayerChats() {
if (player.chat == "/destroy") this.destroy();
}

//#CLIENTSIDE

function onCreated() {
Quattro::AssetManagement::LoadAssetBundle("documentationexample");
this.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
this.bomb = Object::Instantiate(Type::GameObject, this.prefab);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localposition =v3(0,0.5,0);
}
'''Class:''' ''3d_samples_documentation_test''

Everything is the same when it comes to loading and instantiating the prefabs.

The only difference is for this line of code:
{| class="wikitable"
!this.projectile.transform.parent = this.gameobject.transform;
|}
Here, '''''this.gameobject''''' is the NPC GameObject. It is an empty GameObject we attach our prefabs to. We create the prefabs and make them children of this NPC GameObject.

===== Destroying the NPC: =====

* '''''this.destroy''''' will destroy the NPC and all the children as well. (''done on'' ''ServerSide'')
* You could also destroy the NPC and its children using the Unity Binding function: '''''Object::Destroy(this.gameobject).''''' (''done on ClientSide'')

Now in your other script/weapon. To place the NPC in the scene, we use '''''putnpc2(x,y,"")''''';

On ClientSide we trigger server in order to place the NPC containing the prefabs, and inform all the other clients of it, by implementing '''''onActionServerSide()'''''.
findplayer("Graal5918039").addweapon(this.name);

function onActionServerside(cmd,x,y) {
if (cmd == "bomb") {
temp.bombernpc = putnpc2(x,y,"");
temp.bombernpc.join("3d_samples_documentation_test");
}
}

//#CLIENTSIDE

function onCreated() {
triggerserver("gui", this.name, "bomb", player.x, player.y);
}
'''Weapon:''' ''3D/Samples/Examples/DocumentationTest''

File:NPC GO.png

2021-09-02T17:21:26Z

JimmyAkl:

NPC GO

Placing GameObjects in NPC

2021-09-02T17:06:47Z

JimmyAkl:

Another way to make GameObjects visible to all the Players is by placing them in NPCs.

However, placing many NPCs may be heavy on the server, so beware of that whenever you're doing so.

Start off by creating the NPC the normal way:

Create a Script file in classes. You load the assets the same it was done before in weapons; under '''//#CLIENTSIDE'''

[[File:Placing GO in npcs.png|frameless|1048x1048px]]
function onPlayerChats() {
if (player.chat == "/destroy") this.destroy();
}

//#CLIENTSIDE

function onCreated() {
Quattro::AssetManagement::LoadAssetBundle("documentationexample");
this.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
this.bomb = Object::Instantiate(Type::GameObject, this.prefab);
this.bomb.transform.parent = this.gameobject.transform;
this.bomb.transform.localposition =v3(0,0.5,0);
}
'''Class:''' ''3d_samples_documentation_test''

Everything is the same when it comes to loading and instantiating the prefabs.

The only difference is for this line of code:
{| class="wikitable"
!this.projectile.transform.parent = this.gameobject.transform;
|}
Here, '''''this.gameobject''''' is the NPC GameObject. It is an empty GameObject we attach our prefabs to. We create the prefabs and make them children of this NPC GameObject.

===== Destroying the NPC: =====

* '''''this.destroy''''' will destroy the NPC and all the children as well. (''done on'' ''ServerSide'')
* You could also destroy the NPC and its children using the Unity Binding function: '''''Object::Destroy(this.gameobject).''''' (''done on ClientSide'')

Now in your other script/weapon. To place the NPC in the scene, we use '''''putnpc2(x,y,"")''''';

On ClientSide we trigger server in order to place the NPC containing the prefabs, and inform all the other clients of it, by implementing '''''onActionServerSide()'''''.
findplayer("Graal5918039").addweapon(this.name);

function onActionServerside(cmd,x,y) {
if (cmd == "bomb") {
temp.bombernpc = putnpc2(x,y,"");
temp.bombernpc.join("3d_samples_documentation_test");
}
}

//#CLIENTSIDE

function onCreated() {
triggerserver("gui", this.name, "bomb", player.x, player.y);
}
'''Weapon:''' ''3D/Samples/Examples/DocumentationTest''

Uploading and Loading AssetBundles

2021-09-02T17:05:30Z

JimmyAkl:

Up until now, we have been using PrimitiveTypes for our GameObjects.

In this section, we will start using different GameObjects. I will go over how to upload your assetbundles containing all your customized prefabs to the server. How to load, instantiate, and manipulate them.
===Uploading AssetBundles===
You will need to have Unity installed for this part.

You will also need to have the “Quattro3D- Unity Project for bundle asset creation.7z" Unity project installed from the google drive.

I will be going through an example, demonstrating how it’s done.

Begin by choosing what prefabs you want to upload. In our case, I will upload a bomb and a character prefab, which I already have ready in a different project.

Note: Remember you cant put scripts in your asset bundles.

Open the Unity project downloaded (“Quattro3D- Unity Project for bundle asset creation.7z"). This project contains a script that builds the assetbundles and puts them in the Assets/StreamingAssets folder, which will hold all our uploadable files.

In the Assets folder, I will create a new folder and name it Example.

Next I will import my prefabs;

In the top left menu hit (Assets>Import New Asset/Import Package). Go to the location of your prefabs and select them and press Import.

[[File:Uploading assetbundles.png|frameless|371x371px]]

[[File:Prefabs.png|frameless|476x476px]]

[[File:Imported prefabs.png|frameless|773x773px]]

Now that we’ve imported our assets, we’ll create an assetbundle to be uploaded to the server;

Using the Unity way of creating assetbundles by flagging the prefabs:

Select all the prefabs in the asset folder, the Inspector Window should open. At the bottom right of your screen, in the Inspector Window, create or select an existing name for your assetbundle.

The bundle will embed all the assets/prefabs under that flagged directory. You can of course put multiple prefabs/files/subdir...etc inside an asset bundle.

[[File:Adding a tag to the prefabs.png|frameless|541x541px]] [[File:Tagging prefabs.png|frameless|541x541px]]

Now build your asset by pressing on BuildAssetBundles>PackagesBuilder>buildAssetBundles in that project.

The built asset will be stored in the downloaded Unity Project in “Quattro3D- Unity Project for bundle asset creation\Assets\StreamingAssets”

[[File:Uploading assets to the server.png|frameless|712x712px]]

The file that we’ll use to upload to graal should end with “.txt”

[[File:Uploading to the server.png|frameless|800x800px]]

Finally to upload the asset to the server, login on rc, go to levels/assetbundles and drop the “.txt” file there.

It should be automatically downloaded to /Users/”yourusername”/AppData/LocalLow/Graal Worlds/Levels3d/assetbundles[[File:Uploading assets through rc.png|center|frameless|477x477px]]''You’re strongly advised to generate a unitypackage too when you generate an asset bundle and upload it to the server, so that everyone can rebuild the bundle on every platform.''

To view your asset and your prefabs, login to the Client, hit F10 to open the Bundle Explorer and search for your asset name.[[File:Bundle explorer.png|center|frameless|768x768px]]
===ClientSide Loading Assets===
Now to load your prefabs using GraalScript; to your code add the following:

You can use the Bundle Explorer (F10) to copy the path of the AssetBundle.
{| class="wikitable"
|findplayer("Graal5918039").addweapon(this.name);
//#CLIENTSIDE

function onCreated() {

Quattro::AssetManagement::LoadAssetBundle("documentationexample");

}

function onAssetBundleDownloaded(bundlename) {

if (bundlename == "documentationexample") {

player.chat = "example loaded";

temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");

this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);

this.bomb.transform.position = v3(player.x + 5, player.z, player.y);

}

}
|}[[File:Loading prefabs.png|center|frameless|406x406px]]
{| class="wikitable"
! Quattro::AssetManagement::LoadAssetBundle("documentationexample");
|}
The above method loads and downloads the AssetBundle.
{| class="wikitable"
! function onAssetBundleDownloaded(bundlename)
|}
And Implementing the '''''onAssetBundleDownloaded''''' will make sure the Assetbundle has been loaded. We could've skipped this step and directly created the prefab, but best is to make sure the Asset has been loaded.

We then create a prefab:
{| class="wikitable"
!temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
|}
instantiate it,
{| class="wikitable"
!this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);
|}
and give it a position in the scene:
{| class="wikitable"
!this.bomb.transform.position = v3(player.x + 5, player.z, player.y);
|}

Uploading and Loading AssetBundles

2021-09-02T17:04:34Z

JimmyAkl:

Up until now, we have been using PrimitiveTypes for our GameObjects.

In this section, we will start using different GameObjects. I will go over how to upload your assetbundles containing all your customized prefabs to the server. How to load, instantiate, and manipulate them.
===Uploading AssetBundles===
You will need to have Unity installed for this part.

You will also need to have the “Quattro3D- Unity Project for bundle asset creation.7z" Unity project installed from the google drive.

I will be going through an example, demonstrating how it’s done.

Begin by choosing what prefabs you want to upload. In our case, I will upload a bomb and a character prefab, which I already have ready in a different project.

Note: Remember you cant put scripts in your asset bundles.

Open the Unity project downloaded (“Quattro3D- Unity Project for bundle asset creation.7z"). This project contains a script that builds the assetbundles and puts them in the Assets/StreamingAssets folder, which will hold all our uploadable files.

In the Assets folder, I will create a new folder and name it Example.

Next I will import my prefabs;

In the top left menu hit (Assets>Import New Asset/Import Package). Go to the location of your prefabs and select them and press Import.

[[File:Uploading assetbundles.png|frameless|371x371px]]

[[File:Prefabs.png|frameless|476x476px]]

[[File:Imported prefabs.png|frameless|773x773px]]

Now that we’ve imported our assets, we’ll create an assetbundle to be uploaded to the server;

Using the Unity way of creating assetbundles by flagging the prefabs:

Select all the prefabs in the asset folder, the Inspector Window should open. At the bottom right of your screen, in the Inspector Window, create or select an existing name for your assetbundle.

The bundle will embed all the assets/prefabs under that flagged directory. You can of course put multiple prefabs/files/subdir...etc inside an asset bundle.

[[File:Adding a tag to the prefabs.png|frameless|541x541px]] [[File:Tagging prefabs.png|frameless|541x541px]]

Now build your asset by pressing on BuildAssetBundles>PackagesBuilder>buildAssetBundles in that project.

The built asset will be stored in the downloaded Unity Project in “Quattro3D- Unity Project for bundle asset creation\Assets\StreamingAssets”

[[File:Uploading assets to the server.png|frameless|712x712px]]

The file that we’ll use to upload to graal should end with “.txt”

[[File:Uploading to the server.png|frameless|800x800px]]

Finally to upload the asset to the server, login on rc, go to levels/assetbundles and drop the “.txt” file there.

It should be automatically downloaded to /Users/”yourusername”/AppData/LocalLow/Graal Worlds/Levels3d/assetbundles[[File:Uploading assets through rc.png|center|frameless|477x477px]]''You’re strongly advised to generate a unitypackage too when you generate an asset bundle and upload it to the server, so that everyone can rebuild the bundle on every platform.''

To view your asset and your prefabs, login to the Client, hit F10 to open the Bundle Explorer and search for your asset name.[[File:Bundle explorer.png|center|frameless|768x768px]]
===ClientSide Loading Assets===
Now to load your prefabs using GraalScript; to your code add the following:

You can use the Bundle Explorer (F10) to copy the path of the AssetBundle.
{| class="wikitable"
|findplayer("Graal5918039").addweapon(this.name);
//#CLIENTSIDE

function onCreated() {

Quattro::AssetManagement::LoadAssetBundle("documentationexample");

}

function onAssetBundleDownloaded(bundlename) {

if (bundlename == "documentationexample") {

player.chat = "example loaded";

temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");

this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);

this.bomb.transform.position = Vector3::Create(player.x + 5, player.z, player.y);

}

}
|}[[File:Loading prefabs.png|center|frameless|406x406px]]
{| class="wikitable"
! Quattro::AssetManagement::LoadAssetBundle("documentationexample");
|}
The above method loads and downloads the AssetBundle.
{| class="wikitable"
! function onAssetBundleDownloaded(bundlename)
|}
And Implementing the '''''onAssetBundleDownloaded''''' will make sure the Assetbundle has been loaded. We could've skipped this step and directly created the prefab, but best is to make sure the Asset has been loaded.

We then create a prefab:
{| class="wikitable"
!temp.prefab = GameObject::fromassetbundle("documentationexample", "assets/example/bomb.prefab");
|}
instantiate it,
{| class="wikitable"
!this.bomb = Object::Instantiate(Type::GameObject, temp.prefab);
|}
and give it a position in the scene:
{| class="wikitable"
!this.bomb.transform.position = Vector3::Create(player.x + 5, player.z, player.y);
|}

Graal3D Scripting Manual

2021-08-29T19:04:45Z

JimmyAkl: /* Tools */

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The 3D Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Graal3D Client:''' https://drive.google.com/drive/u/0/folders/1rpOli0fxnA-Q7-IpYg3rUFJ44M0PsSxd

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In-game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]
* [[Syncing GameObjects]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Unity UI

2021-08-28T12:56:01Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]In this section we will go over an example of making a UI on unity and uploading and coding it on Client3D in graalscript.

'''Unity Part:'''

Open the “Quattro3D- Unity Project for bundle asset creation” folder using unity hub.

To the assets folder, add we add a folder that will hold all the prefabs of the assetbundle.

To the scene, add a Canvas (in the Hierarchy, right click -> UI -> Canvas). The Canvas will hold all the elements of our UI (buttons, text, scrollbar, images…).

Select the Canvas and in the Inspector go to '''Canvas Scaler''' and select '''Scale With Screen''' for '''UI Scale Mode'''. This will allow the canvas Canvas to expand to full screen on all screens.

Now to build the UI you see above (devtools). Start by adding Text elements (right click on Canvas -> UI -> Text).

For each element, change the name and the text according to its function, change the color to white, add a button component and add a animation component. In the '''Rect Transform''' component, in the Anchor Presets, hold Alt and select top left to position your element.

Add all the Text elements and position them (Inspector, Bundle Explorer, Console, Camera, Rendering).

Now, to add the back button. Add an Image element to the UI, change its name to “back”, and in the image component add the source of the image (drop down in our case). Rotate it -90 deg on the Z axis for it to face left. Add a button component to turn it to a back button that closes the devtools.

For the grey background you see, add and image just like before, change its color to black and change the A field in RGBA to 48 to make it transparent. Add an '''Outline''' component and change the '''Effect Color''' to white to add an outline to the image.
[[File:Unity UI.png|none|thumb|1006x1006px]]

Now that we’ve added all our elements to the Canvas, it’s time to create our animations.

To create an animation, in the top menu (next to Files, Edit, Assets…) go to Window -> Animation -> Animation.

The animation tab should open in the bottom. Select the component you want to create an animation for and create and name the animation.

We will be doing the sliding background image example for the animation.

To record the animation, press on the record button. We want the image to slide in. So put the cursor on time 0s, and change the Pos X to -65 (outside of the screen) then move the cursor to 4s and change the Pos X back to 65. Press the record button again to save the recording.
[[File:Unity UI anim.png|none|thumb|1032x1032px]]

You can press play to view your animation in action. To add the animation to the element; simply add an animation component and add the source of the animation you just created.

Same thing goes for all the other animations.

'''Graal Script Part:'''

Now that we’ve created our prefabs and added the animations, our canvas is ready to be uploaded on the server and scripted. Save the AssetBundle and upload it to the server ([[Uploading and Loading AssetBundles]] for more info).
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
SetTimer(9999);
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::createfromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}
We load the assetbundle the usual way:
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
'''''Settimer(9999);''''' is necessary for the weapon to keep checking for button clicks.

We create and instantiate the canvas prefab.
this.devuiprefab = GameObject::createfromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);
this will display the canvas on the client screen.

To detect button clicks;
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
we first find the button GameObject by name ('''this.devui.transform''' being the transform component of the canvas, and '''btn''' is the button name we want to find).

Next, we add an EventManager to the button component of the gameobject we just found ('''temp.btn.gameobject.GetComponent(Type::UI::Button)''').

And '''this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick")''' to catch all the onClick events.

Finally, we implement '''public function onDevToolClick(go)''' to add functionalities after button is pressed (with '''go''' the gameobject being pressed).

For animations, to add or play an animation, you will need to get the animation component of the GameObject first. (using: '''temp.img.gameobject.GetComponent(Type::Animation)''')
temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
(more script functionalities for animations available here: https://docs.unity3d.com/ScriptReference/Animation.html).

File:Unity UI anim.png

2021-08-28T12:53:16Z

JimmyAkl:

unity ui anim

File:Unity UI.png

2021-08-28T12:51:00Z

JimmyAkl:

unity UI

File:UI1.png

2021-08-28T12:47:24Z

JimmyAkl:

unity ui

Unity UI

2021-08-22T18:51:02Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]

In this section, we will go over an example of creating Unity UI and coding it in GraalScript.

UNITY

In your scene create a canvas (right click -> UI -> Canvas). The canvas will hold all your components (buttons, text, images...). Select the Canvas you created, and in the inspector go to '''Canvas Scaler''' and in the '''UI Scale Mode''' select "'''Scale with Screen'''".

Now you can start adding UI elements to your Canvas. To do so, right click on the Canvas -> UI -> text (example).

To create the Canvas in the image above. Start by adding t
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
SetTimer(9999);
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::createfromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}

Unity UI

2021-08-22T17:37:18Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]

In this section, we will go over an example of creating Unity UI and coding it in graalscript
findplayer("Graal5918039").addweapon(this.name);

//#CLIENTSIDE

function onPlayerChats() {
if (player.chat == "dev") toggle();
}

public function toggle() {
Quattro::AssetManagement::LoadAssetBundle("devtoolsui");
}

function onAssetBundleDownloaded(bundlename) {
if (bundlename == "devtoolsui") {
SetTimer(9999);
this.btns = {"inscpector", "bundleexpl", "console", "camera", "rendering", "back"};
this.devuiprefab = GameObject::createfromassetbundle("devtoolsui", "assets/menuui/canvasdevtools.prefab");
this.devui = Object::Instantiate(Type::GameObject, this.devuiprefab);

for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Quattro::EventManager::AddEventHandlerTo(temp.btn.gameobject.GetComponent(Type::UI::Button));
this.catcheventobject(temp.btn.gameobject, "onClick", "onDevToolClick");
}

Object::Destroy(this.devui, 4);
}
}

public function onDevToolClick(go) {
if (go.name == "inscpector") player.chat = go.name;
if (go.name == "bundleexpl") player.chat = go.name;
if (go.name == "console") player.chat = go.name;
if (go.name == "camera") player.chat = go.name;
if (go.name == "rendering") player.chat = go.name;

if (go.name == "back") close();
}

public function close() {
for (btn : this.btns) {
temp.btn = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, btn);
Object::Destroy(temp.btn.gameobject);
}

temp.img = Quattro::TransformExtensions::FindDeepChild(this.devui.transform, "Image");
temp.anim = temp.img.gameobject.GetComponent(Type::Animation);
temp.anim.play("devtools2");
}

Graal3D Scripting Manual

2021-08-22T17:35:42Z

JimmyAkl: /* Examples and Tutorials */

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The 3D Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Graal3D Client:''' https://drive.google.com/drive/u/0/folders/1rpOli0fxnA-Q7-IpYg3rUFJ44M0PsSxd

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]
* [[Syncing GameObjects]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Unity UI]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]

Unity UI

2021-08-21T16:37:23Z

JimmyAkl:

[[File:UnityUI.png|thumb|889x889px|none]]

In this section, we will go over an example of creating Unity UI and coding it in graalscript

Unity UI

2021-08-21T15:49:18Z

JimmyAkl: Created page with "889x889px"

[[File:UnityUI.png|left|thumb|889x889px]]

File:UnityUI.png

2021-08-21T15:47:41Z

JimmyAkl:

unity ui image

Graal3D Scripting Manual

2021-08-20T16:26:54Z

JimmyAkl:

== Intro ==
[[File:Graal kart start.jpg|center|frame]]
Welcome to the Graal3D Scripting Manual!

This Manual comes in handy for beginners wanting to learn Graal3D Scripting, and advanced developers looking to expand their knowledge, as it contains documentation, examples, tutorials and much more...

What we will focus on in this Manual is programming our gameplay (scripting the behavior of our GameObjects, their interactions, the components attached to them...)

==== How things work in Unity: ====
Unity is the leading platform for building 2D, 3D, VR and augmented reality games. It offers a scripting API in C#, allowing us to interact with the unity editor and the games we want to build.

In the Unity editor, we create and add GameObjects to our scene, we then attach C# scripts to each that will all run upon starting the scene. Unity sort of runs everything for you, it reads through all the lights, cameras, meshes, behaviors… and processes it for you.

==== How things work in Graal3D: ====
Since we will be using the Graal Unity Binding, things will be a bit different.

The Graal Unity Binding is a binding between GraalScript and Unity, it is actually still in alpha, but most functionalities needed are present. The goal of this binding is to mimic the Unity C# scripting system (functions and classes). So if you are familiar with Unity and C#, everything should be easy. If not, then do not worry, I will go over everything step by step and include examples done in C# and compare them to GraalScript for each topic.

The 3D Client (which you will have to download) will serve as the Unity editor, mentioned earlier, which contains the base scene where you instantiate your GameObjects and manipulate them with your GraalScripts.

==== Required Downloads ====
'''Unity 2020.2.2f1:''' https://unity3d.com/get-unity/download/archive

'''The Graal3D Client:''' https://drive.google.com/drive/u/0/folders/1rpOli0fxnA-Q7-IpYg3rUFJ44M0PsSxd

'''RC:''' http://fp4.ca/windows_rc3_beta.zip

==== Tools ====
In game Unity Tools (''mimic the Unity Editor)'' & Game Functionality Tools ''(warping, fixing graphics, starting minigames...):'' [[Tools]]

== Documentation ==

==== Unity ====

* [[Overview On Unity Basics]]

==== AssetBundles ====

* [[Uploading and Loading AssetBundles]]
*[[Placing GameObjects in NPC]]
* [[Syncing GameObjects]]

==== Examples and Tutorials ====
*[[Getting Started Examples]]
*[[3DTutorials|Tutorials]]
*[[Item Manager]]

==== Classes, Functions and Variables ====

* [https://quattro3d.graalonline.com/Documentation/ Quattro3D Scripting]