No-code rules

A rule is a sentence: When something happens, then the game does something. You build them by picking from lists, in the Rules panel (Alt+6). You write no code: the editor writes it.

The panel has three sections: Match, Rules and Test bot. The third is explained in Test bot.

The match#

At the top of the panel is Match, with what applies to the whole game.

Anatomy of a rule#

1. Press New rule.
2. Under When, pick the trigger and fill in its data.
3. Under Then, pick the action and fill in its data.
4. If you want more than one thing to happen, press + Action. Each following action starts with And. The arrow moves an action up in the order and the × removes it.

The rule is written out as a sentence you can read to check that it says what you wanted. A click on the sentence opens or closes the rule.

When the trigger or the action asks for a piece or a zone, you can pick Everything tagged, One piece (or One zone) and, in actions, the touched piece. The Selected button takes what you have selected in the scene.

Texts are written twice, in Spanish and in English, because each player sees the game in their own language.

Triggers#

There are ten.

The examples for "touches", "enters", "reaches", "falls off" and "the game starts" are real sentences from the editor. The rest are ideas for use.

Actions#

There are twenty-three.

The rules that prefabs bring#

Several prefabs add their rule when you place them, and the editor tells you: "A rule was added to make it work. See it under Rules." They are rules like any other: you can open them, change them or delete them.

The coin, danger, goal and trampoline rules talk about a tag: they are added only once and apply to every piece that carries it. The second coin does not add another rule. If you make a box and give it the tag peligro, it also sends the player back to the last checkpoint.

Those of the characters and the signs are one per copy, because each one names its character or its sign.

Characters#

A character is someone else in the scene, besides the player: a neighbor, a guard, a friend who follows you. It always appears at a spawn point and is named by its short name.

The quickest way is to place one of the three prefabs in the Characters group. Each one puts its spawn points in the scene and its rule in the panel:

To change the round, move the spawn points in the viewport like any piece, or add more with the Spawn point prefab and tick them in the character: patrol between points action. At least two are needed.

Switching the view#

The switch the view (camera and controls) action goes from one view to another in the middle of a match: third person, first person, isometric, top-down, side (2D) or flat (2D from above). The option the scene view (go back) returns to the original view. Transition seconds says how long the change takes.

It switches the camera and also the way of moving. If a player triggers the rule, only theirs changes; otherwise, everyone's.

To switch views when passing through a place you do not need a rule: a zone can carry its own view switch. That is in Kinds of game.

How rules become code#

Rules are not a separate system: the editor translates them into code, the same a person would write. The See the code these rules write link, at the end of the list, opens the script at the exact place.

The code goes in scripts/principal.ts, between two marks: // <reglas> and // </reglas>. Each rule appears with its sentence as a comment. This is the fragment for rules 3 and 4 of the tutorial's game. The example was made with the editor in Spanish, so the sentences are in Spanish:

	// Regla 3: Cuando el jugador toca algo con la etiqueta "moneda": quitar la pieza tocada, sumar 1 punto y reproducir el sonido moneda.
	mundo.alTocar('#moneda', (pieza, jugador) => {
		pieza.eliminar();
		sumarPuntos(jugador, 1);
		sonido.tocar('moneda', { para: jugador });
	});

	// Regla 4: Cuando el jugador toca algo con la etiqueta "peligro": reproducir el sonido golpe y reaparecer en el último punto de control.
	mundo.alTocar('#peligro', (pieza, jugador) => {
		sonido.tocar('golpe', { para: jugador });
		jugador.reaparecer();
	});

And rule 5, "reaches 5 points", ended up inside the function that adds points:

/** Suma (o quita) puntos y actualiza lo que se ve. */
function sumarPuntos(jugador: Jugador, cantidad: number): void {
	const antes = jugador.puntos;
	jugador.puntos = Math.max(0, jugador.puntos + cantidad);
	mostrarPuntos(jugador);
	// Cuando el jugador llega a 5 puntos: mostrar "¡Tienes todas! Corre a la meta." y reproducir el sonido victoria.
	if (antes < 5 && jugador.puntos >= 5) {
		interfaz.mensaje(interfaz.t('r_regla_5_1'), { tipo: 'info', para: jugador });
		sonido.tocar('victoria', { para: jugador });
	}
}

You do not need to understand this code to make games. But if you want to learn to program, reading what your own rules write is a good place to start.

Games made with code#

The Coins against the clock (with code) template and the First person, 2D platformer, Top-down, Isometric, Hybrid, Open world and Local multiplayer examples have their logic written by hand. In them the Rules panel starts empty and shows this notice:

"This game is made with hand-written code (Code tab). If you add rules, the editor writes them in a separate block inside the same file, without deleting what is there. Both work together."

Two things change in these games:

• Prefabs do not add their rule without asking. Placing a Coin puts the piece with its moneda tag, but the editor does not add logic to a game made with code on its own. What it does is check whether your code names what you placed (its tag, its piece or its zone). If it does not, it tells you: "This game is made with code and its code does not use "Coin": it does nothing this way. You can add its rule or program it by hand." The Add its rule button, inside the notice, creates the rule and opens the Rules panel. If your code does name it, there is no notice.
• The first rule turns Rules on. From that moment the editor writes its block in the script, the Match settings (clock, final score) take effect and prefabs bring their rule again, as in any other project.

The editor looks for the name in the code and nothing else: it does not know what you use it for. In the isometric example, for instance, placing a Coin does not show the notice, because its script already names moneda (it is the sound it plays). There you create the coin rule by hand, with New rule.

When Rules are turned on, the editor takes the existing code into account:

• The score tables of your code are kept. The Match needs its own high-score table. The editor leaves the ones your code names as they are and adds its own at the end. Up to 0.2.0 it replaced them, and the isometric example was left with a GB323 error: that no longer happens.
• The "No rule ends the game" notice does not appear if your code ends it. The editor also counts the ending set by the hand-written code (a call to juego.terminar), besides the rules with end game and the countdown clock.

Next#

• Playing inside the editor: check that your rules do what you expect.
• Test bot: have a bot finish your game on every difficulty.
• Code: when rules are not enough.