t5-gsc-utils

T5 version of t6-gsc-utils.
If you wish for any feature to be added please create an issue.

Installation

Download the latest version from the releases
Copy it to Plutonium/storage/t5/plugins

Features

Easily add almost any C++ function into GSC:

C++

{
    gsc::function::add("myfunc", [](int a, const std::string& b)
    {
        printf("%i %s\n", a, b.data());
    });
}

GSC

init()
{
    myFunc(1, "hello world");
}

Non-primitive GSC types such as arrays and structs (soon) are also supported and can be implicitly converted to STL containers:

C++

{
    gsc::function::add("sort", [](std::vector<int> vec)
    {
        std::sort(vec.begin(), vec.end());
        return vec;
    });
}

GSC

init()
{
    arr = [];
    arr[arr.size] = 10;
    arr[arr.size] = 5;
    arr[arr.size] = 3;
    arr[arr.size] = 2;
    arr[arr.size] = 9;

    for (i = 0; i < arr.size; i++)
    {
        print(arr[i]);
    }

    print("");

    arr = sort(arr);
  
    for (i = 0; i < arr.size; i++)
    {
      print(arr[i]);
    }
}

More examples can be found here

Functions & Methods

A list of all the functions and methods that are added by this plugin.

IO

fileExists(path): Returns true if the file exists.
writeFile(path, data[, append]): Creates a file if it doesn't exist and writes/appends text to it.
appendFile(path, data): Creates a file if it doesn't exist and appends text to it.
readFile(path): Reads a file.
fileSize(path): Returns file size in bytes.
createDirectory(path): Creates a directory.
directoryExists(path): Returns true if the directory exists.
directoryIsEmpty(path): Returns true if the directory is empty.
listFiles(path): Returns the list of files in the directory as an array.
copyFolder(source, target), copyDirectory(source, target): Copies a folder.
removeDirectory(path[, recursive]): Removes a directory and optionally all its contents.

Command

executeCommand(command), command::execute(command): Executes a console command.
```
fast_restart()
{
    executeCommand("fast_restart");
}
```

addCommand(name, callback), command::add(name, callback): Adds a console command.

init()
{
    addCommand("test_cmd", ::test_cmd);
}

test_cmd(args)
{
    assert(args[0] == "test_cmd");
    print("Hello world", args.size);
}

addClientCommand(name, callback), command::add_sv(name, callback): Adds a client command (can be executed by players through the console).
```
init()
{
    command::add_sv("suicide", ::sv_cmd_suicide);
}

sv_cmd_suicide(args)
{
    self suicide();
}
```
self tell(message): Prints a message to a player's chat.

say(message): Prints a message to all players' chat.

init()
{
    level thread on_player_connected();
}

on_player_connected()
{
    while (true)
    {
        level waittill("connected", player);
        say(string::format("%s connected!", player.name));
        player tell(string::format("Hello %s!", player.name));
    }
}

sendServerCommand(client_num, reliable, text): Executes SV_GameSendServerCommand.

String

va(fmt, ...), formatString(fmt, ...), sprintf(fmt, ...)
string::va(fmt, ...), string::format(fmt, ...): Formats a string:
```
init()
{
    print(va("hello %i %f %s", 1, 1.2, "world"));
}
```

printf(fmt, ...): Formats and prints a string:

init()
{
    printf("hello %i %f %s", 1, 1.2, "world");
}

tolower(string), string::to_lower(string): Converts the string to lowercase.
toupper(string), string::to_upper(string): Converts the string to uppercase.
string::is_numeric(string): Return true if the string contains only numbers.
string::starts_with(string, start): Returns true if the string starts with the specified substring.
string::ends_with(string, end): Returns true if the string ends with the specified substring.
string::replace(string, what, with): Replaces the specified substring with another string.
string::regex_replace(string, expr, with): Replaces the matching substring with another string.
string::regex_match(string, expr): Determines if a regex matches the entire string and returns the matches as an array.

string::regex_search(string, expr): Determines if a regex matches part of the string.

init()
{
    assert(string::to_upper("hello") == "HELLO");
    assert(string::to_lower("HELLO") == "hello");
    assert(string::is_numeric("12345"));
    assert(string::starts_with("hello world", "hello"));
    assert(string::ends_with("hello world", "world"));
    assert(string::replace("hello", "e", "o") == "hollo");
    assert(string::regex_replace("hello", "h|e|l|o", "a") == "aaaaa");
    assert(string::regex_match("hello", "^hello$").size == 1);
    assert(string::regex_search("hello", "e|o"));
}

Misc

array(...): Creates an array from a list of arguments:
```
init()
{
    arr = array(1, 2, 3, 4);
}
```

type(value), typeof(value):

init()
{
    assert(type("hello") == "string");
    assert(type(array()) == "array");
}

fedddddd/t5-gsc-utils