Препроцессор zinc..endzinc

//! zinc

library HelloWorld
{
    function onInit()
    {
         BJDebugMsg("Hello World");
    }
}

//! endzinc

Препроцессор импорта

[//! import [vjass/zinc] "filename"]

// Импорт файла main.zn из папки code с кодом на языке Zinc
//! import zinc "code/main.zn"

// Импорт файла libTimerUtils.j из папки code с кодом на языке vJass
//! import vjass "code/libs/libTimerUtils.j"

// Импорт файла spell.j из папки code с кодом на текущем языке
//! import "code/spell1.j"

Основы синтаксиса

Библиотеки

library CodeGoesHereo
{
    // code goes here:
       // * глобальные переменные
       // * функции
       // * структуры
       // * интерфейсы
       // * прочие типы (динамические массивы, указатели на функцию)

    function onInit()
    {
        // Ваша onInit() функция будет вызвана во время инициализации карты
    }
}

library A
{
    public function AABoom()
    {
        BJDebugMsg("BOOM IN A");
    }
    function onInit()
    {
        BJDebugMsg("Library A");
    }
}

library B requires A
{
    function onInit()
    {
        BJDebugMsg("Library B");
        Boom();
        Boom();
    }
}

library A requires B, C, D, ...

Приватные и публичные конструкции библиотек

library PublicTest
{
    public
    {
        integer PublicTest1;
        integer PublicTest2;
        integer PublicTest3;
        // Все эти переменные публичные и доступны другим библиотекам
    }
}

library PublicTest
{
    public integer PublicTest1;
    public integer PublicTest2;
    public integer PublicTest3;
}

Глобальные переменные

( (constant) тип имя ( = значение) )

тип имя[размер]

тип имя[размер1][размер2]

library PublicTest
{
    // Набор приватных констант
    constant integer SPELL_ID = 'A000';
    constant real    HEIGHT = 10.0;
    constant integer UNIT_COUNT = 7, ITEM_COUNT = UNIT_COUNT*6;
        
   // A, B, C, D глобальные переменные целочисленного типа,
   // объявленные как публичные. 
   // Переменные B и C инициализированы значением
   // Переменная D инициализирована значением переменной B
    public integer A;
    public integer B = 1;
    public integer C=2, D=B;

    // X: массив действительных чисел, стандартным размером 8192 ячейки
    // Y: массив действительных чисел, размером 16000 ячеек
    // Z: двумерный массив действительных чисел, размером 200*200
    // Все массивы приватные
    real X[], Y[16000];
    real Z[200][200];

    function onInit()
    {
        A = B;
        X[0] = A;
        X[1] = B + 1;
        D = B;
        D = 7;
        C = D*3;
        Y[10000] = D;
        Z[4][4] = 10;
    }

}

Функции

function имя ([аргументы]) -> возвращаемыйТип { тело }

SomeFunctioon(values)

library FunctionTest
{
    integer x = 0;

    function increaseX()
    {
        // Функция, которая просто увеличивает значение
        // глобальной переменной
        x = x + 1;
    }

    function sum3(integer a, integer b, integer c) -> integer
    {
       // Сумма 3х чисел
       return a+b+c;
    }

    function onInit()
    {
        increaseX();
        x = sum3( x, x, 7);
        increaseX();
        /* BJDebugMsg = blizzard.j функция и I2S = wc3 нативная  */
        BJDebugMsg( I2S(x) );

        // Выведет сообщение "10" в игре
    }
}

Присваивание

(thing to assign) = (value)

Условный оператор

if (условие) { инструкции1 } else { инструкции2 }

library IfTest
{
    integer x = 0;

    function onInit()
    {
        if(x==0)
        {
            BJDebugMsg("it is 0");
        }
        else
        {
            BJDebugMsg("it is not 0");
        }

        x = GetRandomInt(0,3);
            
        // Короткий вариант, {} не требуется, поскольку выполняется только 1 инструкция
        // (делает ровно то же самое что и предыдущий условный блок)
        if(x==0)  BJDebugMsg("it is 0");
        else      BJDebugMsg("it is not 0");

        x = GetRandomInt(0,6);
        if(x==5)
        {
            BJDebugMsg("Today is your lucky day, because you got a 5");
        }
        else if (x==0)
        {
            // В Zinc нет такой конструкции как elseif, но поскольку
            // после else стоит только 1 if инструкция, в обявлении
            // нового блока нет необходимости. В результате, мы выдим
            // поведение идентичное elseif.
            BJDebugMsg("Today is your unlucky day,")
            BJDebugMsg(" you got a 0");
        }
        else
        {
            BJDebugMsg("Normal day");
            // Вложенный условный оператор
            if( x==4) {
                BJDebugMsg("But hey, at least it is a 4, that is good");
            }
        }

    }

}

Логические операторы

static if

library OptionalCode requires optional UnitKiller
{
    constant boolean DO_KILL_LIB = true

    function fun()
    {
        unit u = GetTriggerUnit();
        // Следующий код используется для убийства юнита.
        // Однако, если в коде карты существует библиотека
        // UnitKiller и пользователь установил константе
        // DO_KILL_LIB значение ture, вместо стандартной
        // функции KillUnit будет вызвана функция UnitKiller
        // из этой библиотеки.
        // Все это проверяется на этапе компиляции, удаляя
        // не удовлетворяющий статичному условию код.
        static if(DO_KILL_LIB && LIBRARY_UnitKiller )
        {
            //static if because if the UnitKiller
            // library was not in the map, using a normal
            // if would not remove this line of code and
            // therefore it would cause a syntax error.
            // (unable to find function UnitKiller)
            UnitKiller(u);
        }
        else
        {
            KillUnit(u);
        }
    }

}

library UnitKiller
{
    function UnitKiller(unit u)
    {
        BJDebugMsg("Unit kill!");
        KillUnit(u);
    }
}

Цикл while

while (условие) {инструкции}

library WhileTest
{
    function onInit()
    {
        integer x = 5;
        while( x > 0)
        {
            BJDebugMsg( I2S(x) );
            //decrease x
            x = x - 1;
        }
    }
}

Цикл for

for ( диапазон ) { инструкции }

library WhileTest
{
    function onInit()
    {
        integer x, n=7;
        // Числа от 0 до 9,
        // в порядке возрастания
        for ( 0 <= x < 10)
        {
            BJDebugMsg( I2S(x) );
        }

        // Числа от 9 до 0
        // в порядке убывания
        for ( 10 > x >= 0)
        {
            BJDebugMsg( I2S(x) );
        }

        // Числа от 1 до 10,
        // в порядке возрастания
        for( 1 <= x <= 10 )
        {
            BJDebugMsg( I2S(x) );
            //decrease x
            x = x - 1;
        }

        // Числа от 0 до n-1,
        // в порядке возрастания
        for ( 0 <= x < n )
        {
            BJDebugMsg( I2S(x) );
        }
    }
}

break

debug

debug {statements }

library Test
{
    function onInit()
    {
        debug
        {
            BJDebugMsg("Debug mode is enabled");
        }
    }
}

Локальные переменные

Структуры

library WhileTest
{
    // Структура
    struct A
    {
        integer x,y,z;
    }

    // Интерфейс
    interface B
    {
        method move();
    }

    // Структура на 20000 экземпляров
    struct[20000] C
    {
        real a,b,c;
        string s,t;
    }

    // Интерфейс на 20000 экземпляров
    interface[30000] D
    {
        integer meh;
        method transform(integer a) -> integer;
    }

    // "Структура-массив"
    struct myArr[]
    {
        static constant integer meh = 30004;
        integer a;
        integer b;
    }

    // Структура-массив в 10000 ячеек
    struct myErr[10000]
    {
        integer x,y,z;
    }

    interface F
    {
        method balls(integer x) = null; // Аналогичен 'defaults nothing' в vJass
        method bells(integer y) -> real = 0.0 ; // Аналогичен defaults 0.0 в vJass для return real

        // Статичный метод create для этого интерфейса
        static method create();
    }

    struct G
    {
        static method onCast()
        {
            KillUnit( GetTriggerUnit() );
        }

        static method onInit() {
            // Статичный метод onInit
            trigger t= CreateTrigger();

            // Супротив vJass в котором использовался бы синтаксис function G.onCast.
            TriggerAddAction(t, static method G.onCast);
        }
        integer x;

        // Перегрузка операторов:

        method operator< (G other) -> boolean
        {
            return (this.x < other.x)
        }

        method operator[](integer x) -> real
        {
            return x*2.5;
        }

        method operator readOnly() -> integer
        {
            return 0;
        }
    }

    module H
    {
        method kill() { BJDebugMsg("Kill it"); }
    }

    struct K
    {
        module H; // Реализация модуля H
        optional module XX; // Опциональная реализация модуля XX

        delegate G myg; // Делегат
    }

}

Динамические массивы

library Test
{
    // Динамический целочисленный массив размерностью 5
    type myDinArray extends integer[5];

    // Динамический массив действительных значений, размером 6 и резервом в 10000
    type myDinArray2 extends real[6, 10000];
}

Указатель на функцию

library Test
{
    // Функциональный тип с единственным аргументом типа юнит
    type unitFunc extends function(unit);

    // Функциональный тип с двумя аргументами целочисленного типа и возвращаемым
    // значением логического типа (использовать не будем, просто для демонстрации)
    type evFunction extends function(integer,integer) -> boolean;

    function TortureUnit(unit u)
    {
        BJDebugMsg(GetUnitName(u)+" is being tortured!");
        KillUnit(u);
    }

    function HealUnit(unit u)
    {
        SetWidgetLife(u, 1000);
    }

    /* Данная функция вызывает F(u), если юнит является союзником и G(u), если противником.
    Пример бессмысленный и сильно уступает по скорости выполнения обычному if-else ветвлению,
    но сгодится для демонстрации функционального типа. */
    function AllyEnemyFunctionPicker(player p, unit u, unitFunc F, unitFunc G)
    {
        if (IsUnitAlly(u, p)) {
            F.evaluate(u);
        } else {
            G.evaluate(u);
        }
    }

    function test(unit u)
    {
        // Используем функции в качестве аргументов здесь
        AllyEnemyFunctionPicker( Player(0), u,  TortureUnit, HealUnit );
        // Пытает союзника или исцеляет врага
    }

}

Анонимные функции

library Test
{
    function test1()
    {
        TimerStart(CreateTimer(), 5.0, false, function() {
             BJDebugMsg("5 seconds since you called test1");
        });
    }


    type unitFunc extends function(unit);
    function AllyEnemyFunctionPicker(player p, unit u, unitFunc F, unitFunc G)
    {
        if (IsUnitAlly(u, p) ) {
            F.evaluate(u);
        } else {
            G.evaluate(u);
        }
    }

    /* Пример функционального типа */
    function test2(unit u)
    {
        unitFunc F,  G;

        F = function(unit u) {
            BJDebugMsg("We are torturing "+GetUnitName(u)+" again");
            KillUnit(u);
        };

        G = function(unit u) { SetWidgetLife(u, 100); };
            
        AllyEnemyFunctionPicker( Player(0), u, F, G);
        // Пытает союзника или исцеляет врага.
        // Обратите внимание, это другой вид реализации примера
        // из предыдущего пункта статьи.
    }

}