Please read it (and criticize it)

Rules:
1. Basic types: Number (no distinction between real and integers)
String
Boolean (true and false)

(I steal the idea from BASIC)
Numbervariable
Stringvariable$
Booleanvariable%
Users neednt declare the variables. Enough just define them.

2. Non case sensitive.
3. Two different kind of code module: Library
Trigger
4. Library: only functions and local variables in functions, but no constants and global variables.
Trigger: functions, variables, constants and the main function which has the same name like the trigger source code and will start when the system call that trigger.
5. Functions can contain variable declaration, but no constant declaration. Those variables are local in the function.
6. Comments with // (double slash).

Syntax:

Library source file:

// here start the library source code
Library;

Function1([Name1, Name2, ...]) {
[Var
Name1 := Value;
Name2 := Value;
Array Name1[Index1, Index2, ...];
Array Name2[Index1, Index2, ...];
EndVar]
Statements;
Return [NameX];
}

Function2([Name1, Name2, ...]) {
[Var
Name1 = Value;
Name2 = Value;
EndVar]
Statements;
Return [NameX];
}

// Here is the end of the library source code. The file name must have a .cli extension.

// Here starts the trigger source code.

Trigger;

[Library Library1Name;
Library Library2Name;]

[Const
Name1 = Value;
Name2 = Value;
EndConst

Var
Name1 = Value;
Name2 = Value;
Array Name1[Index1, Index2, ...];
Array Name2[Index1, Index2, ...];
EndVar;]

Function1([Name1, Name2, ...]) {
[Variable
Name1 = Value;
Name2 = Value;
EndVariable]
Statements;
Return [NameX];
}

Function2([Name1, Name2, ...]) {
[Variable
Name1 = Value;
Name2 = Value;
EndVariable]
Statements;
Return [NameX];
}

Trigger([Name1, Name2, ...]) {
[Var
Name1 = Value;
Name2 = Value;
EndVar]
Statements;
Return;
}
// Here is the end of the trigger source code. The file name must have a .ctr extension.

Everything between [ and ] is optional, except the array declaration. I.E.: Array Name$[ Index1, Index2, ... ], this is the part of the syntax.
The Trigger function ALWAYS Void. The Trigger Function name the same like the trigger source code name and the same like the built in trigger name:
Let say we have a trigger in the game: EndOfTurn
In this case the trigger source code name is: EndOfTurn.ctr
The trigger main function:
Void EndOfTurn() {
[Var
Name1 = Value;
Name2 = Value;
Endvar]
Statements;
Return;
}

Instructions:

Statements:

Simple Statements:

Assignment:
variable = expression;
expression: must be type compatible with the variable

Function calls:
i.e.:
MyFunction();

Structured statements:

1. Compound statement:
All the simple statements between the { and } brackets.
i.e.:
{
a = 158;
b = MyFunc(125,25);
}

2. If statement:

If (Boolean expression)
Simple or compound statement1
//optional
else
Simple or compound statement2

If the Boolean expression is true then statement1 is executed, otherwise the statement2 is executed.

3. While statement:

While (Boolean expression)
Simple or compound statement

The while statement executes as long as the Boolean expression returns true.

4. Do While statement:

Do
Simple or compound statement
While (Boolean expression)

The while statement executes as long as the Boolean expression returns true.

5. For statement:

For(Initial value, final value, counter)
Simple or compound statement

The for statement executes as long as the final value is true.

Expression:
The order of the execution can be determined by brackets ( and )
1. Numeric:

Constant (i.e. 16)
Variable (i.e. N)
Function Sum(A, B, C);
Addition + Op1 + Op2 (i.e. 16+12)
Subtraction - Op1 - Op2 (i.e. 16-N)
Multiplication * Op1 * Op2 (i.e. 12*N)
Division / Op1 / Op2 (i.e. 12/2)
Negation - -Op (i.e. -N)
Increment ++ Op++ (i.e. ++N) Op must be a number variable!
Decrement -- Op-- (i.e. N--) Op must be a number variable!

2. String

Constant (i.e. 'AbcD')
Variable (i.e. S)
Function Uppercase('abc');
Concatenation + Op1 + Op2 (i.e. S+'cd')

3. Boolean

Constant (i.e. true)
Variable (i.e. T)
Function Good();
And & Op1 & Op2
Or | Op1 | Op2
Not ! ! Op

Relational operators (Result ALWAYS Boolean)
Numeric: (Op1 and Op2 are numeric expressions)
Equality == Op1 == Op2
Inequality != Op1 != Op2
Less-than < Op1 < Op2
Greater-than > Op1 > Op2
Less-than or equal to <= Op1 <= Op2
Greater-than or equal to >= Op1 >= Op2

String: (Op1 and Op2 are string expressions)
Equality == Op1 == Op2
Inequality <> Op1 <> Op2

Calling Order:
Let say we wold like to play with the "myscenario" scenario. The system first start to load all the triggers and libraries from the default directory After looking for triggers and libraries in the "myscenario" scenario directory:
i.e.:
first ...\default\mod\*.ctr (triggers)
...\default\mod\*.clb (libraries)
after
...\myscenario\mod\*.ctr (triggers)
...\myscenario\mod\*.clb (libraries)
If the system find triggers in the "myscenario" library with the same names like the defaults, then the system will use those "myscenario" triggers to control the game.

I will wait this weekend (Sunday evening). If nobody wants any changes, I start to write the interpreter from next Monday.

// 1. 09-07-1999 I chnage from := to = and = to ==.
// 2. 09-08-1999 Users neednt declare the variables. It is only an option. Enough just define them.

Blade Runner

I Still don't like the := operator...
I think younger people that have not been subjected to Pascal will wonder what planet we flew in from

//This event will create the Angry Mothers civ in 20,30 and give the
//Nasty Evil Buggers 1000 monetary units and the Evil Empire tech
//if the Nasty Evil Buggers conquer the Really Important Province
//before 1230 OR if the Annoyingly Good Guys are destroyed before that same year

Trigger;

var
REP$ = "Realy Important Province";
NEB$ = "Nasty Evil Buggers";
AGG$ = "Annoyingly Good Gays";
AM$ = "Angry Mothers";
Tech$ = "Evile Empire";
endvar

Turnbeginnig(BeginYear)
{
If (BeginYear < 1230)
{
If (Owner(REP$)) == Civ(NEB$) | Destroyed(AGG$))
{
CreateCiv(20,30,AM$);
NewTech(NEB$) = Tech$;
Treasure(NEB$) = Treasure(NEB$) + 1000;
}
}
}

// The name of this trigger file will be Turnbeginnig.ctr.

The another example:

//This procedure will show a "You are really poor" message to all players of
//civilizations that have less than 100 monetary units or less than 2 cities and
//the turn is year 1900.

Trigger;

Var
Message$ = "You are really poor";
I;
Treasury;
Cities;
Name$ = "";
Dummy1;
Dummy2;
Dummy3;
EndVar

Turnbeginning(BeginYear)
{
If (BeginYear == 1900)
{
For(0,MaxCivs-1,I++)
{ GetCiv(I,Name$,Treasury,Cities,Dummy1,Dummy2,Dummy3);
If(Treasury < 100 | Cities <= 2)
MessageBox(Message$);
}
}

// The name of this trigger file will be Turnbeginnig.ctr too.

Looks better than the XML.

Thanks. Yes it looks much better than the XML IMO. I am not sure about all of it, but since its a made-up example it doesn't matter too much. The one that has me really confused is near the bottom of the post:

Civ(I,Treasury,Cities);

I don't understand what it does... I was expecting something like:

If( Civ(I,Treasury) < 100 | Civ(I,numCities) <= 2)...

My idea was: You can get all the important variables from a civ just one function calling.
I.E.: Civ(Number, Name, Treasury, Territory, RelativeStrength, BlaBla, ...);
(When you call the Civ function you can use the Number or the Name, and you will get back the informations in the rest of the variables.)

Osiris,

To use the variable declaration part are only an option. I used in my example because I write Pascal programs 15 years ago. Here is an another example without variable declaration:

//This event will create the Angry Mothers civ in 20,30 and give the
//Nasty Evil Buggers 1000 monetary units and the Evil Empire tech
//if the Nasty Evil Buggers conquer the Really Important Province
//before 1230 OR if the Annoyingly Good Guys are destroyed before that same year

Trigger;

Turnbeginnig(BeginYear)
{
REP$ = "Realy Important Province";
NEB$ = "Nasty Evil Buggers";
AGG$ = "Annoyingly Good Gays";
AM$ = "Angry Mothers";
Tech$ = "Evile Empire";
If (BeginYear < 1230)
{
If (Owner(REP$)) == Civ(NEB$) | Destroyed(AGG$))
{
CreateCiv(20,30,AM$);
NewTech(NEB$) = Tech$;
Treasure(NEB$) = Treasure(NEB$) + 1000;
}
}
}

// The name of this trigger file will be Turnbeginnig.ctr.

Blade Runner

I imagine a few complex function calling to get and set important variables. These need to organized in logic way.

1. GetGame(Players, CivNum, MapMeasureX, MapMeasureY, ...
2. GetCiv(CivNumber, Name, Computer, Treasury, Cities, Teritory, MilitaryStrength, Government, ...
3. GetMap(X, Y, City, SurfaceType, SurfaceSubType, IsProvince, MMilitaryTF, ...
4. GetProvinces(ProvNumber, ProvCivNumber, ProvCivname, Population, PMilitaryTF, ...

If we organize the game system this way, the users neednt remember 100 or more built-in function. They can call the right function, and they get all the information. The built-in function calling has Built-in variables. If you want to keep the value you need to store own variable or array. On the other side if we syncronized all the built-in variables that consume a lot of valuable processor time. IMHO enough to syncronize the value when the macro call the built-in getter function. The setter functions are the same.

Well, I have some scepticism about the GetGame(Players, CivNum, MapMeasureX, MapMeasureY, ... type functions. But you're the one coding it so try whatever you think will work best. I admit I don't think in terms of scenario design much. You're probably right that to have some functions that access all the most common things to tweak is the most important.

I'm not really convinced by my new idea either. At later stages I need to investigate what the quickest solution is: whether this means changing the built-in variables synchron in the java code, or synchronizing the variables when the user calls a function. I seems to me that he function calling is quicker, but I will experiment when we have the alfa version of the game and the macro interpreter.