About

CENTVRION is the programming language for the modern roman.

Documentation

Example code

Hello World

DESIGNA x UT "Hello World!"
DICE x

Recursive Fibonacci number function

DEFINI fib x UT {
    SI x EST NULLUS TUNC {
        REDI NULLUS
    } ALUID SI x EST I TUNC {
        REDI I
    } ALUID {
        REDI ((INVOCA fib (x-II)) + (INVOCA fib (x-I)))
    }
}

Number guessing game

VOCA FORS

DESIGNA correct UT FORTIS_NUMERUS I C
DESIGNA gvess UT NULLUS

DUM FALSITAS FACE {
    DESIGNA gvess UT AUDI_NUMERUS
    SI gvess MINUS correct TUNC {
        DICE "Too low!"
    } ALUID SI gvess PLUS correct TUNC {
        DICE "Too high!"
    } ALUID {
        ERUMPE
    }
}

DICE "You guessed correctly!"

Variables

Variables are set with the DESIGNA and UT keywords. Type is inferred.

DESIGNA x UT XXVI

Variable can consist of lower-case letters, numbers, as well as _.

Data types

NULLUS

NULLUS is a special kind of data type in CENTVRION, similar to the null value in many other languages. NULLUS can be 0 if evaluated as an int or float, or an empty string if evaluated as a string. NULLUS cannot be evaluated as a boolean.

Strings

Strings are written as text in quotes (' or ").

DESIGNA x UT "this is a string"

Integers

Integers must be written in roman numerals using the following symbols:

Symbol	Value
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

Each of the symbols written by themself is equal to the value of the symbol. Different symbols written from largest to smallest are equal to the sum of the symbols. Two to three of the same symbol written consecutively is equal to the sum of those symbols (only true for Is, Xs, Cs or Ms ). A single I written before a V or X is equal to 1 less than the value of the second symbol. Similarly, an X written before a L or C is 10 less than the second symbol, and a C written before a D or M is 100 less than the second symbol.

Because of the restrictions of roman numerals, numbers above 3.999 are impossible to write in the base CENTVRION syntax. If numbers of that size are required, see the MAGNUM module.

The number 0 can be expressed with the keyword NULLUS.

Negative numbers

Negative numbers can be expressed as NULLUS minus the value. For an explicit definition of negative numbers, see the SUBNULLA module.

Floats

The base CENTVRION syntax does not allow for floats. However, the FRACTIO module adds a syntax for fractions.

Booleans

Booleans are denoted with the keywords VERITAS for true and FALSITAS for false.

Arrays

Arrays are defined using square brackets ([]).

Conditionals

SI/TUNC

If-then statements are denoted with the keywords SI (if) and TUNC (then). Thus, the code

DESIGNA x UT VERITAS
SI x TUNC {
    DICE I
    REDI NULLLUS
}

DICE NULLUS

> I

Will return I (1), as the conditional evaluates x to be true.

Boolean expressions

In conditionals, EST functions as an equality evaluation, and MINUS (<) and PLUS (>) function as inequality evaluation.

ALUID

When using SI/TUNC statements, you can also use ALUID as an "else".

DESIGNA x UT VERITAS
SI x TUNC {
    DICE I
} ALUID {
    DICE NULLUS
}

> I

SI statements may follow immediately after ALUID.

DESIGNA x UT II
SI x EST I TUNC
    DICE I
ALUID SI x EST II TUNC
    DICE II
ALUID
    DICE III

> II

Boolean operators

The keyword ET can be used as a boolean "and". The keyword AUT can be used as a boolean "or".

DESIGNA x UT VERITAS
DESIGNA y UT FALSITAS
SI x ET y TUNC {
    DICE I
} ALUID SI x AUT y TUNC {
    DICE II
} ALUID {
    DICE III
}

> II

Loops

DONICUM loops

DESIGNA x UT NULLUS
DONICUM y UT NULLUS USQUE X FACE {
    DESIGNA x UT x + y
}
DICE x

> XLV

DUM loops

DESIGNA x UT NULLUS
DUM x PLUS X FACE {
    DESIGNA x UT x+I
}
DICE x

> XI

PER loops

DESIGNA x UT [I, II, III, IV, V]
PER y IN x FACE {
    DICE y
}

> I
> II
> III
> IV
> V

Functions

Functions are defined with the DEFINI and UT keywords. The REDI keyword is used to return. REDI must have exactly one parameter. REDI can also be used to end the program, if used outside of a function.

Calling a function is done with the INVOCA keyword.

DEFINI square x UT {
    REDI (x*x)
}

DICE (INVOCA square XI)

> CXXI

Built-ins

DICE

AUDI

AUDI_NUMERUS

ERUMPE

LONGITUDO

Modules

Modules are additions to the base CENTVRION syntax. They add or change certain features. Modules are included in your code by having

VOCA %MODULE NAME%

In the beginning of your source file.

Unlike many other programming languages with modules, the modules in CENTVRION are not libraries that can be "imported" from other scripts written in the language. They are features of the compiler, disabled by default.

FORS

VOCA FORS

The FORS module allows you to add randomness to your CENTVRION program. It adds 2 new built-in functions: FORTIS_NUMERUS int int and FORTIS_ELECTIONIS ['a].

FORTIS_NUMERUS int int picks a random int in the (inclusive) range of the two given ints.

FORTIS_ELECTIONIS ['a] picks a random element from the given array. FORTIS_ELECTIONIS array is identical to array[FORTIS_NUMERUS NULLUS ((LONGITUDO array)-I)].

FRACTIO

VOCA FRACTIO

The FRACTIO module adds floats, in the form of base 12 fractions.

In the FRACTIO module, . represents 1/12, : represents 1/6 and S represents 1/2. The symbols must be written from highest to lowest. So 3/4 would be written as "S:.".

Fractions can be written as an extension of integers. So 3.5 would be "IIIS".

The symbol | can be used to denote that the following fraction symbols are 1 "level down" is base 12. So after the first |, the fraction symbols denote 144ths instead of 12ths. So 7 and 100/144 would be "VIIS:|::", as "7 + 100/144" is also "7+9/12+4/144".

A single "set" of fraction symbols can only represent up to 11/12, as 12/12 can be written as 1.

MAGNUM

VOCA MAGNUM

MAGNUM adds the ability to write integers larger than MMMCMXCIX (3.999) in your code, by adding the thousands operator, "_".

When _ is added after a numeric symbol, the symbol becomes 1.000 times larger. The operator can be added to the same symbol multiple times. So "V_" is 5.000, and "V__" is 5.000.000. The strict rules for integers still apply, so 4.999 cannot be written as "IV_", but must instead be written as "MV_CMXCIX".

All integer symbols except I may be given a _.

SUBNULLA

VOCA SUBNULLA

The SUBNULLA module adds the ability to write negative numbers as -II instead of NULLUS-II.