Author: tremblin

• if you declare a constant vector (through initialisation), its elements are now constant

e.g.

const v (identity 4)
= [v 1 1] 2 ; fail

• Added const. Functions and labels are always constant.
• * is now the dereference operator.

* Will be the dereference operator but address will remain @

All the so called constants will be real constants. const will be the same as var except it will take a constant value after the variable name. This only affects the = operation as builtins can still change constants if they don’t check, however none of the builtin API will do so, so they will effectively be constant.

• Add -limits command line switch to disable instruction per second limit
• Add rest of casts (vector, map, function, label, pointer)
• Fix joystick events

There are now 2 and will currently be more casts. e.g.:

var foo
/* ... some code where foo may or may not be converted  to a vector, like vector_add but foo may still never have been set */
some_func foo

If some_func is expecting a vector and foo hasn’t been typed to vector yet, this might create an error depending what some_func does. So to get around this you can use:

some_func (vector foo)

Or:

/* this way, setting it right away is preferable to avoid a vector copy */
var foo
= foo (vector foo)

number and string already exist in 3.0.0. 3.0.1 will have vector, map, function, label and pointer.

• Fix broken joystick
• Add srand and time
• Move all builtins that return values to expression ops
• Remove some examples, update the rest to new API (and fix some bugs)
• Ditched type safety, var is now used to declare all variables
• Add instructions per second counter with +debug command line switch (and a font)

As I said, I would be limiting operations per second. CoinHunt blows away everything else at 6 million instructions per second while firing rapidly. It can be designed much better (linked lists and BSPs for example.) DOOMED only reaches the hundreds of thousands barely. So I set the limit to 10 million instruction per second. CoinHunt (with changes I made) runs well on Celeron N5095 at 6 million and that’s a low end but modern computer so I think 10 million is good.

I will probably add a command line switch to disable the limit in the next version.

I’ve added an instructions/second counter (need +debug command line switch). The cube example is really lightweight, while the town example gives a little over 7,000 instructions per second. I’m going to take the heaviest example and multiply it by 5 or 10 and set a limit. This will make games run everywhere, well optimised and of a certain small arcadey distinction. The result is averaged every 5 seconds.

You can optimise for lower instruction counts, e.g.:

= x (* x 2)
= x (+ x 1)

Is 2 instructions but:

= x (+ (* x 2) 1)

Is 1 and does the same thing.