Comment : GSC#

Commencer#

Bien que GSC soit très limité, il offre des fonctionnalités que tout développeur C ++ de base devrait déjà connaître. Si vous ne le connaissez pas, ne vous inquiétez pas! Ils sont super simples à apprendre et à utiliser.

Vous devez avoir connaissance du chargement des scripts GSC avant d’essayer de les écrire, veuillez vérifier notre guide à ce sujet

Commentaires#

Les commentaires existent de deux manières, les commentaires d’une ligne ou les commentaires de bloc de plusieurs lignes.

// This is a one-line comment.

/*
This is a comment across
multiple lines!
*/

Déclaration de fonctions#

Vous pouvez déclarer des fonctions dans GSC en lui donnant un nom, suivi d’un (){ et une clôture } à la fin de votre fonction. Exemple:

myFunction()
{
 self iprintlnbold("^2My First Function!"); 
}

Fonctions d’appel#

Pour appeler une fonction, il existe différentes façons de s’y prendre.

Les fonctions peuvent être threadées ou appelées séquentiellement.

Si une fonction est threadée, cette fonction est exécutée pendant que le script continue, tandis que si une fonction est appelée séquentiellement, le script attend que la fonction soit terminée avant de continuer.

function(); // The script will stop at this line and carry out function() before going down to the next line.
thread function(); // This will start function() and carry on to execute the next line.

Si vous appelez une fonction sur une entité, par exemple unnamedent thread dostuff(), puis dans la fonction dostuff(), vous pouvez faire référence à unnamedent comme self.

Exemple:

something()
{
 ent = getent("ent","targetname");
 ent function();
}

function()
{
 self moveZ(150, 5);
}

Exemple avec contexte :

connected()
{
  self endon("disconnect");
  for(;;)
  {
    self waittill("spawned_player");
    self thread myFunction();
  }
}
myFunction()
{
 self iprintlnbold("^2My First Function!"); 
}

Utilisation de variables#

Les variables peuvent être utilisées de plusieurs façons, mais dans tous les cas, elles sont utilisées pour stocker des données pendant toute la durée du jeu.

Les variables se présentent sous différentes formes: entiers, flottants, entités, chaînes, tableaux et booléens, il existe également plusieurs façons différentes de stocker des variables.

Une variable simple est simplement déclarée à l’aide de

variable = data;

Cette variable peut être utilisée dans la fonction actuelle et dans toute fonction qui la transmet en tant qu’argument, ou qui y est appelée (elle serait donc utilisée comme self).

Les variables peuvent être globales (qui peuvent être utilisées dans tous les threads sans avoir besoin d’être appelées) à l’aide de l’icône

level.variable = data;

ou ils peuvent être attribués à des entités individuellement

entity.variable = data;

pour des choses comme player.health (entier, déjà intégré, mais peut être modifié) et level.teamBased (booléen).

Mathématiques & Opérateurs#

Les mathématiques sont utilisées tout au long des scripts pour obtenir de nombreuses valeurs différentes, que ce soit la distance entre deux objets ou pour calculer une équation.

Par exemple, une variable peut recevoir des données d’une équation mathématique simple.

myVariable = 5 * 2;

Cependant, ce n’est pas vraiment utile. (Vous pouvez simplement faire le calcul avant de le placer dans le script) Mais, les variables peuvent être calculées en utilisant d’autres variables.

varAnswer = var1 + var2;

Il existe plusieurs opérateurs que vous pouvez utiliser pour les mathématiques.

+ :: Addition
- :: Subtraction
* :: Multiplication
/ :: Division
% :: Modulus (Remainder)
= :: Equals
++ :: Increment (+1)
-- :: Decrement (-1)
+= :: Incrementation (requires number)
-= :: Decrementation (requires number)

Exemples:

var++; // Set var to var + 1
var--; // Set var to var - 1
var += int; // Set var to var + int
var -= int; // Set var to var - int

Si les relevés#

Une instruction « if » est utilisée pour vérifier si certaines données remplissent certaines conditions, puis pour exécuter du code en fonction du résultat.

Pour comprendre cette section, vous devez d’abord connaître les opérateurs utilisés pour comparer les données :

== :: Equal To
!= :: Not Equal To
!  :: Negation (Not equal to)
<  :: Less than
>  :: Greater than
<= :: Less or Equal to
>= :: Greater or Equal to
&& :: And
|| :: Or

Exemple:

if (3 < 5) {
    iprintln("Condition met");
} else {
    iprintln("Condition not met");
}

Cela peut également être utilisé pour vérifier les conditions des variables du joueur ou simplement des variables.

self.condition = false;
if (self.condition) { // is true?
    self iprintln("self.condition is true");
} else {
    self iprintln("self.condition is false");
}

Vous pouvez également utiliser un « else if » dans l’instruction. Ceci est utilisé dans un scénario où vous souhaitez vérifier plusieurs comparaisons.

if(var1 == var2)
{
  // If above arguement is true
}
else if(!var1 && var3)
{
  // If var1 is false but var3 is true
}
else
{
  // If all other if statements were false
}

Dans GSC, vous pouvez vérifier si une variable est définie comme une condition. Cette fonction est appelée isDefined, il prend la variable comme seul paramètre et renvoie true/false. Si une variable est égale à undefined ou n’est tout simplement pas défini du tout, vous devriez obtenir false.

var = 5;
var2 = 6;

if (isDefined(var)) { // var is defined as 5
    iprintln("var is defined");
    var2 = undefined; // undefine var2
}

if (isDefined(var2)) { // this should not be met as var2 was undefined.
    iprintln("var2 is defined");
} else if (!isDefined(var2)) {
    iprintln("var2 is undefined");
}

Boucles#

Les boucles se présentent sous différentes formes...

Pendant que :: Une boucle while est une boucle qui continue à boucler WHILE l’argument est vrai.

Pour :: Une boucle for est une boucle qui boucle un nombre défini de fois

Foreach :: Une boucle foreach est utilisée lorsque vous souhaitez effectuer quelque chose sur tous les éléments d’un tableau.

while#

Alors que les boucles sont essentiellement pour les boucles, mais vérifie seulement si la condition est vrai / faux.

Dans cet exemple, si number est vrai (pas 0) alors il continuera à fonctionner. Mais, chaque fois que la boucle while est exécutée, nous diminuons number par 1.

number = 5;
while (number) {
    iprintln("Number equals: " + number);
    number--;
}

iprintln("The while loop has ended."); // this will only be seen if the loop ended

/*

5 prints should have been made:
"Number equals: 5"
"Number equals: 4"
"Number equals: 3"
"Number equals: 2"
"Number equals: 1"
"The while loop has ended."

*/

for#

Pour les boucles sont des boucles qui peuvent être infinies ou des boucles qui ne s’exécutent que jusqu’à ce qu’une condition quelconque soit remplie.

Une boucle infinie ressemble à :

for(;;) {
    iprintln("Infinite loop!");
    wait 0.05; // **IMPORTANT! ONLY RUNS EVERY SERVER FRAME!**
}

Une boucle qui s’arrêtera après i n’est plus inférieur à var, ce qui équivaut à 10.

var = 10;
for(i=0; i<var; i++) {
    iprintln("Looping! " + i);
}

foreach#

Les boucles Foreach sont des boucles qui vous permettent de faire quelque chose sur chaque élément d’un tableau.

Une boucle foreach ressemble à :

foreach(something in array)
{
  // Do something
}

Un exemple ressemblerait à ceci :

foreach(player in level.players) // "For every player in the game"
{
    player giveWeapon("dsr50_mp", 0); // Give every player in the game a DSR 50.
}

Attendre#

GSC est exécuté sur chaque trame de serveur, qui se compose de 20 trames de serveur par 1 seconde. Si cela est appelé sur une fonction non threadée, il contiendra le serveur/l’entité.

wait 0.05; // 1 server frame
wait 0.5;  // 10 server frames
wait 1;    // 20 server frames
wait (1);  // 20 server frames

Interrupteur#

Les cas de commutation sont utiles pour vérifier le cas de nombreuses valeurs. Ceci est généralement considéré comme plus rapide et recommandé à utiliser qu’un if déclaration.

value = 3;
switch (value)
{
    case 1:
        iprintln("Value was 1");
        break;
    case 2:
        iprintln("Value was 2");
        break;
    case 3:
        iprintln("Value was 3");
        break;
    default:
        iprintln("Value was not found");
        break;
}

Notifier / Endon / Waittill#

Ces 3 fonctions vous permettent de faire attendre un script pour des événements spécifiques, puis de déclencher ces événements dans différentes parties des scripts.

Ce qui suit déclenche le killed_player notification le self (qui est un joueur dans ce cas) :

self notify("killed_player");

Si vous utilisez player waittill("x") ou player endon("x"), puis à l’aide d’un level notify("x") ne déclenchera ni l’un ni l’autre - le niveau n’est pas la même entité que le joueur, et tous les déclencheurs des entités sont indépendants.

L’utilisation des fonctions est facile. Tout d’abord, décidez de l’entité sur laquelle vous souhaitez attendre le déclencheur. C’est un joueur la plupart du temps, mais si vous voulez un déclencheur global, utilisez level.

Ensuite, vous devez décider quel déclencheur utiliser. Vous pouvez choisir l’un ou l’autre endon ou waittill - ils sont tous deux explicites, l’un mettra fin à la fonction dans laquelle il s’exécute lorsqu’il est déclenché, et l’autre « attendra » jusqu’au déclencheur spécifié.

Exemple:

spawnPlayer()
{
  self notify("spawned");
  
  /*
     ... Code snipped ... this is another type of 
     comment that can span multiple lines. 
  */
  
}

Callback_PlayerKilled(attacker, some other arguments)
{
  self endon("spawned"); // This makes callback_playerkilled() terminate when "spawned" is triggered in spawnplayer().
}

Y compris les autres CGC#

En utilisant le format #include path\filename; vous pouvez inclure un fichier GSC dans votre fichier GSC existant.
Les noms de fichiers peuvent avoir ou ne pas avoir l’extension de fichier, les dossiers sont séparés par une barre oblique inverse.
Tout le chemin doit être dans un seul mot, peut avoir des espaces / onglets / nouvelles lignes avant et après le nom de fichier jusqu’au point-virgule.
Les inclusions doivent être effectuées avant qu’un type de fonction ne soit défini dans le fichier.

Éléments HUD#

Note Pour certaines choses (éléments HUD à l’esprit) vous êtes Obligatoire pour utiliser un include, tout simplement farfelu #include maps\mp\gametypes\_hud_util; tout en haut de votre script et ce qui suit fonctionnera.

Vous pouvez obtenir du texte sur les écrans des joueurs avec une relative facilité. Pour ce faire, nous utilisons les éléments suivants :

Pour setPoint vous pouvez utiliser l’une des valeurs suivantes ou simplement des valeurs directes. Notez que si vous utilisez des valeurs, les guillemets ne sont pas obligatoires.

self.someText setPoint(<POINT1>, <POINT2>, <POINT3>, <POINT4>);

<POINT1> This is the Horizontal "Point"
<POINT2> This is the Vertical "Point"
<POINT3> This can either be a Number (X) or a "Point". (Horizontal)
<POINT4> This can either be a Number (Y) or a "Point". (Vertical)

Horizontal:
LEFT
RIGHT
CENTER

Vertical:
BOTTOM
TOP
CENTER

Remarque: il y en a plus, mais je ne vous suggère pas de les utiliser.

Exemple:

self.someText = self createFontString( "Objective", 1.5 );
self.someText setPoint( "CENTER", "CENTER", "CENTER", "CENTER" );
self.someText setText( "^1forum.plutonium.pw" ); 

Portage à partir d’autres jeux#

Ce guide contient des parties du guide CoD 4 GSC de Zeroy, mais rien n’a été changé à ce sujet pour nos jeux, cela montre à quel point GSC est vraiment polyvalent. Vous pouvez prendre du code simple d’autres jeux et le porter avec un minimum d’effort.

Ressources/Crédits#

Télécharger le script J’ai utilisé ce qui démontre certains des sujets discutés ici.

Présentation de Zeroy’s CoD4 GSC

Exemple CoDScript d’Ingramz

Guide de création d’un élément HUD d’iAegle