Well I'm not sure yet. The programming language I'm developing for it is called Zen, which is a name that doesn't really pertain to much other than my meditative (
) state while coding it, but I like it anyway. So I'm thinking something along the lines of ZenStudio or something.
If anyone's interested, the basic idea is this.
I want to combine the two different notions of an IDE and a level editor. Every entity in your levels will be of a certain class (OOP style) which will be written in the Zen language. These classes can be sub-classed to create specific behaviours for different objects, for example, the Player class can be sub-classed to Enemy, and the behaviours can be changed. The basic idea here is that when you select an object, you'll be able to choose it's class, or even create a new one, in a programming environment built straight into the level editor. This works well because default properties for the objects can be set as they usually would be in any level editor (such as coordinates, rotation and scale), except in an OO fashion, so everything will be very flexible. Different object types will have different properties, and you can create them as you go. Also, I'm starting to think about ideas such as having people publish their classes and being able to download them directly from the editor, and use them there and then. It will definitely make the game development experience much more interactive and immediate.
As for the language itself, so far it's extremely robust and fast. Unlike most of my WIP posts where the languages I create are dynamically typed, this one is statically typed, which means linking can be done prior to execution and so there are never any complex lookups. In fact there's not a single 'if' statement in the entire virtual machine (the component that runs the code). But, you'll be glad to know, a lot of it can be written to look like it's a dynamically typed language, as I have added type inference:
function main() // default 'void'
{
var a = 12; // 'a' becomes an 'int' and stays that way
var v = new Vector3(3, 4, 5); // 'v' becomes a reference to a 'Vector3' object
}
One interesting feature I've added is interfaces. Now, when I said there were never any complex lookups, I lied. There's one for the first time you call a method in an interface. This is because the ability to implement multiple interfaces means you can't know where in the v-table for a class a method's implementation is at compile time, because you don't know the type of the object, so at runtime, the method is looked-up, and as soon as it's found, it caches the result so it never has to look it up again.
Interfaces will be very useful for this project. Take this for example:
// There's no 'standard response' to collisions, so make an interface for anything that can collide, and let the class implement the action
interface Collidable
{
function CollideWith(Collidable other);
}
// An 'Enemy' is a 'Player' and has a specific collision response.
// This is a crap example because 'Player' will probably implement the 'Collidable' interface, but at least it shows the syntax.
class Enemy : Player [Collidable]
{
// construct with name, and pass name to 'Player' constructor
construct(string name)
: base(name)
{
}
// Implement collision response
function CollideWith(Collidable other)
{
if (other is Enemy) // Dynamic type checking
// ...
else if (other is Player)
// ...
else if (other is Vehicle)
// ...
else if (other is Bullet)
Die();
}
}
Anyway that's a brief intro to how the system will work. Progress is going well on one of it's most crucial components so I'm feeling pretty confident
"everyone forgets a semi-colon sometimes." - Phaelax
