SpritesMind.Net

Code: Select all

include( "genesis.h" );

// structs can store variables, they're like simple containers for data
struct Vector2
{
	var x : fix32;
	var y : fix32;
}

// classes are like structs, but they can also have methods.
// additionally, they are allocated via 'new' syntax, and are allocated on the heap rather than the stack (internally, this is done via MEM_alloc function)
class TestClass
{
	var position : Vector2;
	
	// Initialize game entity
	function virtual Init() : void
	{
		// do stuff
	}
}

// classes can inherit from other classes
class TestSubclass : TestClass
{
	function override Init() : void
	{
		super(); // <-- this is used to call the parent method implementation
		
		this->position.x = 50;
	}
}

// modules look a lot like static classes - you can put fields and functions in here and access them via Module.[..] syntax.
// at the moment, modules are more like classes than namespaces - so for instance you cannot put structs or classes inside of them (only fields and functions).
module SomeModule
{
	var someField : u32;
}

function main() : int
{
	var testSubclass : TestSubclass* = new TestSubclass();
	testSubclass->Init();
	
	// this is how you access module fields and functions
	SomeModule.someField = 42;
	
	while( true )
	{
		VDP_waitVSync();
	}

	return 0;
}

Code: Select all

#include <genesis.h>

typedef struct Vector2_ 
{
    fix32 x;
    fix32 y;
} Vector2;

typedef struct TestClass_ 
{
    Vector2 position;
    void (*Init) ( struct TestClass_* this );
} TestClass;

void TestClass_Init( TestClass* this )
{
}

void TestClass_AssignFuncPointers( TestClass* this )
{
    this->Init = TestClass_Init;
}

TestClass* new_TestClass()
{
    TestClass* newObj = MEM_alloc( sizeof( TestClass ) );
    TestClass_AssignFuncPointers( newObj );
    return newObj;
}

typedef struct TestSubclass_ 
{
    TestClass base;
} TestSubclass;

void TestSubclass_Init( TestSubclass* this )
{
    TestClass_Init(this);
    this->base.position.x = 50; // <-- note that it automatically inserts "base." when accessing position. The compiler understands and keeps track of inheritance, unlike C.
}

void TestSubclass_AssignFuncPointers( TestSubclass* this )
{
    TestClass_AssignFuncPointers( this );
    this->Init = TestSubclass_Init;
}

TestSubclass* new_TestSubclass()
{
    TestSubclass* newObj = MEM_alloc( sizeof( TestSubclass ) );
    TestSubclass_AssignFuncPointers( newObj );
    return newObj;
}

// "module" was sort of meant to be used as an alternative to naming conventions. So for instance if you were to rewrite the VDP_* functions in this language, instead of, say,
// VDP_waitVSync(), you'd have a module named "VDP", and a function inside "waitVSync()", and you'd call it via "VDP.waitVSync();", which internally just translates to VDP_waitVSync();
u32 SomeModule_someField;

int main(  )
{
    TestSubclass* testSubclass = new_TestSubclass();
    testSubclass->Init(testSubclass);
    SomeModule_someField = 42;
    while( true ){
        VDP_waitVSync();
    }
    return 0;
}